On-demand Rides and Deliveries Solution is currently available only to select partners.

Pakiet SDK Dysku Google na iOS – pierwsze kroki

Za pomocą pakietu SDK Driver możesz usprawnić nawigację i śledzenie postępów w aplikacji Podróże i zamówienia. Pakiet Driver SDK zapewnia aktualne informacje o lokalizacji i zadaniach floty silnikówje i dostarcza rozwiązanie na żądanie.

SDK Driver sprawi, że usługi Fleet Engine i usługi niestandardowe będą znać lokalizację i stan pojazdu. Na przykład pojazd może mieć wartość ONLINE lub OFFLINE, a jego lokalizacja zmienia się w miarę postępów podróży.

Minimalne wymagania systemowe

  • Na urządzeniu mobilnym musi być zainstalowany iOS 13 lub nowszy.
  • Xcode wersja 14 lub nowsza.
  • Wymagania wstępne

    W tym przewodniku przyjęto założenie, że Twoja aplikacja ma już zaimplementowany pakiet SDK nawigacji, a backend Fleet Engine jest skonfigurowany i dostępny. Przykładowy kod pokazuje jednak, jak skonfigurować pakiet SDK nawigacji.

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

    Konfiguracja projektu

    Pakiet SDK Driver możesz skonfigurować za pomocą CocoaPods.

    Korzystanie z CocoaPods

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

    1. Utwórz plik Podfile dla pakietu SDK sterownika 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 do niego zależności. Oto przykład zależności:

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

      Oto przykład podów wersji alfa i beta dla pakietów SDK sterownika:

      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 poda. Spowoduje to zainstalowanie interfejsów API określonych w pliku Podfile wraz z ich zależnościami.

      pod install
      
    4. Zamknij Xcode, a następnie kliknij dwukrotnie plik .xcworkspace projektu, aby uruchomić Xcode. Od teraz do otwierania tego projektu musisz używać pliku .xcworkspace.

    Zainstaluj XCFramework

    XCFramework to pakiet binarny, którego używasz do zainstalowania pakietu SDK sterownika. Ten pakiet może być używany na wielu platformach, w tym na komputerach z chipsetem M1. Z tego przewodnika dowiesz się, jak ręcznie dodać do projektu XCFramework z pakietem SDK sterownika 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. Jeśli jeszcze nie istnieje, utwórz grupę w ramach grupy projektów.

    4. Przeciągnij plik gRPCCertificates.bundle znajdujący się w katalogu Resources archiwum ZIP zawierającego element XCFramework do katalogu najwyższego poziomu w projekcie Xcode. W razie potrzeby wybierz Kopiuj elementy.

    5. Aby zainstalować pakiet SDK Driver, przeciągnij plik GoogleRidesharingDriver.xcframework do projektu: Frameworks, Libraries, and Embedded Content W razie potrzeby wybierz Kopiuj elementy.

    6. Wybierz projekt w Nawigatorze projektu i wybierz aplikację.

    7. Otwórz kartę Etapy kompilacji i w oknie Połącz plik binarny dodaj te biblioteki i biblioteki, jeśli jeszcze ich tam 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
      • OpenGLES.framework
      • QuartzCore.framework
      • SystemConfiguration.framework
      • UIKit.framework
      • LocalAuthentication.framework
      • WebKit.framework
    8. Zamiast projektu wybierz projekt, a potem otwórz kartę Ustawienia kompilacji. W sekcji Inne flagi łączące dodaj ‑ObjC do debugowania i publikowania. Jeśli nie widzisz tych ustawień, zmień filtr na pasku ustawień kompilacji z Podstawowy na Wszystkie.

    Wersje alfa/beta pakietu SDK

    Aby skonfigurować wersję alfa lub beta pakietu SDK sterownika 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 na temat CocoaPods.

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

    Gdy Twój projekt pojawi się na liście dostępu, możesz uzyskać dostęp do poda.

    1. Utwórz plik Podfile na potrzeby pakietu SDK do wyświetlania reklam na iOS 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 do niego zależności. Oto przykład 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 poda. To polecenie instaluje interfejsy API określone w Podfile wraz z ich zależnościami.

      pod install
      
    4. Zamknij Xcode, a następnie kliknij dwukrotnie plik .xcworkspace projektu, aby uruchomić Xcode. Od teraz do otwierania tego projektu musisz używać pliku .xcworkspace.

    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 uwierzytelniać te żądania, pakiet SDK Driver wywołuje Twój obiekt zgodny z protokołem GMTDAuthorization. Obiekt jest odpowiedzialny za dostarczenie wymaganego tokena dostępu.

    Deweloper aplikacji decyduje o sposobie generowania tokenów. Implementacja powinna umożliwiać wykonywanie tych czynności:

    • Pobieranie tokena dostępu (prawdopodobnie w formacie JSON) z serwera HTTPS.
    • Przeanalizuj token i zapisz go 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 internetowego JSON (JWT) do autoryzacji.

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

    W tym przykładzie zaimplementowano 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 uzyskać instancję GMTDVehicleReporter, musisz najpierw utworzyć instancję GMTDRidesharingDriverAPI za pomocą identyfikatora dostawcy, VehicleID, sterContext i accessTokenProvider. Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Do instancji GMTDVehicleReporter możesz też uzyskać dostęp 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. Aby odpowiadać 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 o tym, że usługi backendu otrzymały aktualizację pojazdu i jego stan.

    • vehicleReporter(_:didFail:withError:)

      Informuje detektora, że nie udało się zaktualizować pojazdu. Dopóki śledzenie lokalizacji jest włączone, GMTDVehicleReporter wysyła najnowsze dane do backendu Fleet Engine.

    Oto przykład, który 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 pakietu SDK Driver, 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, w aplikacji locationTrackingEnabled możesz true ustawić wartość GMTDVehicleReporter. GMTDVehicleReporter automatycznie wysyła aktualizacje lokalizacji. Po dopasowaniu usług i przypisaniu pojazdu do podróży GMTDVehicleReporter wysyła trasę automatycznie, gdy GMSNavigator działa w trybie nawigacji (jeśli miejsce docelowe jest ustawione na setDestinations).

    Trasa ustawiona podczas aktualizacji podróży będzie tą samą, do której prowadzi sesja nawigacji. Aby udostępnianie podróży mogło działać 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 podróży i pojazdów są wysyłane do backendu Fleet Engine w regularnych odstępach czasu na podstawie wartości ustawionej na locationUpdateInterval. Jeśli locationTrackingEnabled ma wartość false, aktualizacje są zatrzymane, a ostatnie żądanie aktualizacji pojazdu jest wysyłane do backendu Fleet Engine w celu ustawienia stanu pojazdu na GMTDVehicleState.offline. Zobacz updateVehicleState, aby zapoznać się ze specjalnymi uwagami na temat obsługi błędów, gdy locationTrackingEnabled ma wartość false.

    W tym przykładzie włączamy śledzenie 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 odstęp czasu obsługi aktualizacji to 5 sekund. Maksymalny obsługiwany odstęp aktualizacji to 60 sekund. Częstsze aktualizacje mogą skutkować wolniejszymi żądaniami i błędami.

    Aktualizowanie stanu pojazdu

    Poniższy przykład pokazuje, 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. Zwykle występuje przy pierwszej aktualizacji po uruchomieniu. Poniższy przykład pokazuje, jak postępować w przypadku tego błędu:

    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 offline

    Aplikacja może wyłączyć aktualizacje i włączyć tryb offline. Na przykład po zakończeniu zmiany kierowcy aplikacja może ustawić locationTrackingEnabled na false. Wyłączenie aktualizacji powoduje ustawienie stanu pojazdu na OFFLINE w backendzie Fleet Engine.

    Swift

    vehicleReporter.locationTrackingEnabled = false
    

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;