Pierwsze kroki ze sterownikiem SDK na iOS

Możesz użyć pakietu Driver SDK, aby usprawnić nawigację i śledzenie w aplikacji Podróż i Postępy zamówienia. Pakiet Driver SDK dostarcza aktualizacje lokalizacji pojazdów i zadań w usłudze Fleet Engine Fleet Engine na żądanie.

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

Minimalne wymagania systemowe

  • Na urządzeniu mobilnym musi być zainstalowany 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 nawigacji SDK oraz że backend Fleet Engine jest skonfigurowany i dostępny. Przykładowy kod pokazuje, jak skonfigurować pakiet SDK nawigacji.

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

    Konfiguracja projektu

    Menedżer pakietów Swift

    Pakiet SDK sterownika można zainstalować za pomocą menedżera pakietów Swift. Aby dodać pakiet SDK, upewnij się, że zostały usunięte wszystkie dotychczasowe zależności od tego pakietu.

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

    1. Otwórz plik Xcode project lub workspace i kliknij Plik > Dodaj zależności pakietów.
    2. Wpisz https://github.com/googlemaps/ios-driver-sdk jako adres URL, naciśnij Enter, aby pobrać pakiet, a następnie kliknij „Dodaj pakiet”.
    3. Aby zainstalować określony version, w polu Reguła zależności ustaw jedną z opcji opartych na 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 pakiet GoogleRidesharingDriver zostanie dodany do wyznaczonego miejsca docelowego main. Gdy skończysz, kliknij „Dodaj pakiet”.
    5. Aby sprawdzić instalację, przejdź do panelu General środowiska docelowego. Zainstalowane pakiety powinny być widoczne w sekcji Frameworks, Biblioteki i Umieszczone treści. Możesz też wyświetlić sekcję „Zależności pakietów” w aplikacji „Project Navigator”, aby sprawdzić pakiet i jego wersję.

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

    1. W Xcode wybierz kolejno „File” (Plik) > Packages (Pakiety) > Update To Last Package Versions (Aktualizuj do najnowszych wersji pakietów).
    2. Aby sprawdzić instalację, przejdź do sekcji Zależności pakietów w Project Navigator i sprawdź pakiet i jego wersję.

    Aby usunąć istniejące zależności pakietu SDK sterownika dodane za pomocą polecenia 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 usunąć pakiet Driver SDK zainstalowany ręcznie, wykonaj te czynności:

    1. W ustawieniach konfiguracji projektu Xcode znajdź Frameworks, Biblioteki i Umieszczone treści. Użyj znaku minusa(-), aby usunąć tę platformę:

      • GoogleRidesharingDriver.xcframework

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

    CocoaPods

    Aby skonfigurować pakiet SDK sterownika 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 i 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, który uwzględnia te 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 uwzględnia jako zależności pody w wersji alfa i beta 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 oraz wszystkich zależności, jakie mogą one mieć.

      pod install

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

    Więcej informacji znajdziesz we wprowadzeniu na CocoaPods.

    Instalacja ręczna

    XCFramework to pakiet binarny służący do instalacji pakietu Driver SDK. Tego pakietu możesz używać na wielu platformach, w tym na komputerach z technologią Apple Silicon. Z tego przewodnika dowiesz się, jak ręcznie dodać do projektu komponent XCFramework zawierający pakiet SDK Driver i skonfigurować ustawienia kompilacji w Xcode.

    Pobierz plik binarny pakietu SDK i zasoby:

    1. Wyodrębnij 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 jeszcze nie istnieje, utwórz w grupie projektów grupę Platforms.

    4. Aby zainstalować pakiet SDK sterowników, przeciągnij plik GoogleRidesharingDriver.xcframework do projektu w sekcji Frameworks, Libraries and Embedded Content (Narzędzia, biblioteki i umieszczone treści). Po pojawieniu się monitu wybierz „Kopiuj elementy”, jeśli to konieczne.

    5. Przeciągnij pobrany plik GoogleRidesharingDriver.bundle do katalogu najwyższego poziomu projektu Xcode. Gdy pojawi się taka prośba, wybierz Copy items if needed.

    6. Wybierz projekt z Nawigatora projektów i wskaż miejsce docelowe aplikacji.

    7. Otwórz kartę Etapy kompilacji i w sekcji Link Binary with Libraries 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, a nie konkretny cel, i otwórz kartę Ustawienia kompilacji. W sekcji Inne flagi łączące dodaj -ObjC na potrzeby debugowania i publikowania. Jeśli nie widzisz tych ustawień, zmień filtr na pasku ustawień kompilacji z Podstawowe na Wszystkie.

    Dodaj plik manifestu prywatności Apple

    1. Pobierz pakiet pliku manifestu dotyczącego prywatności dla pakietu Driver SDK na iOS: GoogleRidesharingDriverPrivacy.
    2. Rozpakuj plik, aby uzyskać dostęp do usługi GoogleRidesharingDriverPrivacy.bundle.
    3. Dodaj obiekt GoogleRidesharingDriverPrivacy.bundle do nawigatora projektów Xcode za pomocą jednej z tych metod. Upewnij się, że jest zaznaczone pole „Dodaj do celów” w obszarze docelowym Twojej aplikacji. Po dodaniu plik PrivacyInfo pojawi się w nawigatorze projektów i możesz sprawdzić jego wartości.
      4. Zrzut ekranu z informacjami o ochronie prywatności w Xcode
    4. Sprawdź, czy plik manifestu prywatności został dodany. Aby to zrobić, utwórz archiwum aplikacji i wygeneruj raport prywatności z archiwum.

    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 Twój obiekt zgodny z protokołem GMTDAuthorization. Obiekt odpowiada za udostępnienie wymaganego tokena dostępu.

    Jako deweloper aplikacji decydujesz o sposobie generowania tokenów. Implementacja powinna umożliwiać:

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

    Szczegółowe informacje o tokenach oczekiwanych przez serwer Fleet Engine znajdziesz w artykule Tworzenie tokena sieciowego JSON (JWT) na potrzeby 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 implementacji 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 z użyciem tych parametrów: providerID, pojazdID, driverContext i accessTokenProvider. Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Możesz też uzyskać dostęp do instancji GMTDVehicleReporter bezpośrednio z poziomu interfejsu driver 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łuchuj zdarzeń VehicleReporter

    GMTDVehicleReporter okresowo aktualizuje pojazd, gdy locationTrackingEnabled ma wartość true. Aby odpowiedzieć na te okresowe aktualizacje, dowolny obiekt może zasubskrybować zdarzenia GMTDVehicleReporter, działając 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 słuchacza, że aktualizacja pojazdu się nie powiodła. Dopóki włączone jest śledzenie lokalizacji, GMTDVehicleReporter będzie nadal wysyłać najnowsze dane do backendu Fleet Engine.

    Poniższy 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 do GMSRoadSnappedLocationProvider

    Aby aktualizować lokalizację w pakiecie SDK sterownika, GMTDVehicleReporter musi być ustawiony 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: GMTDVehicleReporter. GMTDVehicleReporter automatycznie wysyła aktualizacje lokalizacji. Gdy usługi dopasowują się i przypiszą pojazd do podróży, GMTDVehicleReporter automatycznie wysyła aktualizacje trasy, gdy GMSNavigator działa w trybie nawigacji (gdy cel podróży jest ustawiony w setDestinations).

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

    Jeśli locationTrackingEnabled ma wartość true, aktualizacje dotyczące podróży i pojazdu są regularnie wysyłane do backendu Fleet Engine na podstawie wartości ustawionej dla locationUpdateInterval. Jeśli locationTrackingEnabled ma wartość false, aktualizacje są zatrzymywane, a do backendu Fleet Engine wysyłane jest żądanie ostatniej aktualizacji pojazdu w celu ustawienia stanu pojazdu na GMTDVehicleState.offline. Specjalne uwagi dotyczące obsługi błędów, gdy locationTrackingEnabled ma wartość false, znajdziesz w sekcji 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ś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ą skutkować wolniejszym przesyłaniem żądań i błędami.

    Zaktualizuj stan pojazdu

    Z przykładu poniżej dowiesz się, jak ustawić stan pojazdu na ONLINE. Więcej informacji znajdziesz w sekcji 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. Poniższy przykład pokazuje, jak obsłużyć 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 przełącz pojazd do trybu offline

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

    Swift

    vehicleReporter.locationTrackingEnabled = false

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;