Pierwsze kroki ze sterownikiem SDK na iOS

Za pomocą pakietu Driver SDK możesz zapewnić Aplikacja Postęp dotyczący podróży i zamówień. Pakiet Driver SDK udostępnia pojazd aktualizacje lokalizacji i zadań w rozwiązaniu floty rozwiązań na żądanie w ramach przejazdów i dostaw na żądanie.

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

Minimalne wymagania systemowe

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

    • Wymagania wstępne

    W tym przewodniku przyjęto założenie, że Twoja aplikacja korzysta już z funkcji Nawigacja SDK oraz Fleet Wyszukiwarka backend jest skonfigurowany i dostępny. Przykładowy kod zawiera jednak jak skonfigurować nawigacyjny pakiet SDK.

    Musisz też włączyć Maps SDK na iOS w projekcie Google Cloud i uzyskać interfejs API Klucz.

    Konfiguracja projektu

    Menedżer pakietów Swift

    Pakiet Driver SDK można zainstalować za pomocą programu Menedżer pakietów Swift. Aby dodać pakiet SDK, upewnij się, że masz usunięto 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 Xcode project lub workspace i przejdź do File > (Plik >). Dodaj zależności pakietów.
    2. Jako URL wpisz https://github.com/googlemaps/ios-driver-sdk i naciśnij Enter. i pobierz pakiet, a potem kliknij „Dodaj pakiet”.
    3. Aby zainstalować określony element version, w polu Reguła zależności ustaw jedną z z użyciem opcji opartych na wersji. W przypadku nowych projektów zalecamy określenie najnowszej wersji i za pomocą opcji „Dokładna wersja” . Gdy skończysz, kliknij „Dodaj pakiet”.
    4. W oknie Wybierz produkty w pakiecie sprawdź, czy GoogleRidesharingDriver zostanie dodany do wyznaczonej wartości docelowej main. 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ć „Zależności pakietów” w narzędziu „Project Navigator” aby zweryfikować pakiet i jego wersję.

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

    1. W przypadku uaktualnienia z wersji wcześniejszej niż 9.0.0 musisz usunąć te zależności: GoogleMapsBase, GoogleMapsCore oraz GoogleMapsM4B po uaktualnieniu. Nie usuwaj zależności dla GoogleMaps Więcej informacji: Informacje o wersji 9.0.0

      W ustawieniach konfiguracji projektu Xcode znajdź Frameworks, Libraries, i Umieszczone treści. 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” (Plik > >) Pakiety > Zaktualizuj do najnowszych wersji pakietu”.
    3. Aby sprawdzić poprawność instalacji, przejdź do sekcji Zależności pakietów w narzędziu Project Navigator. aby zweryfikować pakiet i jego wersję.

    Aby usunąć istniejące zależności Driver 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 Kod Xcode workspace, jeśli nie używasz ich do żadnych innych celów niż CocoaPods.

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

    1. W ustawieniach konfiguracji projektu Xcode znajdź Frameworks, Biblioteki i umieszczone treści. Aby usunąć, użyj znaku minusa(-). następujący schemat:

      • GoogleRidesharingDriver.xcframework

    2. W 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 tego polecenia.
       sudo gem install cocoapods

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

      cd <path-to-project>

    3. Uruchom polecenie instalacji poda. Spowoduje to zainstalowanie interfejsów API określonych w Podfile wraz z ewentualnymi zależnościami.

      pod install

    4. Zamknij Xcode, a następnie otwórz (kliknij dwukrotnie) obszar roboczy .xcworkspace Twojego projektu aby uruchomić Xcode. Od tej pory musisz używać .xcworkspace, aby otworzyć projekt.

    Zapoznaj się z wprowadzeniem do CocoaPods tutaj .

    Instalacja ręczna

    XCFramework to pakiet binarny używany do instalacji Pakiet SDK sterownika. Możesz korzystać z tego pakietu na wielu platform, w tym komputerów korzystających z systemu Apple krzem. Z tego przewodnika dowiesz się, jak ręcznie dodać komponent XCFramework zawierający Pakiet Driver SDK do projektu i konfigurowanie 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 w projektach AI. Jeśli dopiero zaczynasz korzystać z systemu iOS, utwórz nowy projekt i wybierz Szablon aplikacji.

    3. Utwórz w grupie projektów grupę z platformami, jeśli taka grupa nie istnieje już teraz.

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

    5. Przeciągnij pobrany plik GoogleRidesharingDriver.bundle na najwyższy poziom. w Twoim projekcie Xcode. Gdy pojawi się odpowiedni komunikat, wybierz Copy items if needed.

    6. Wybierz projekt w narzędziu Project Navigator, a następnie jako cel aplikacji.

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

    8. Wybierz projekt zamiast konkretnego środowiska docelowego i otwórz kompilację . W sekcji Inne flagi łączące dodaj -ObjC do: oraz funkcji debugowania. Jeśli te ustawienia nie są widoczne, zmień na pasku ustawień kompilacji z Podstawowe na Wszystkie.

    Sprawdź 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.

    Plik manifestu prywatności Apple jest zawarty w pakiecie zasobów SDK. Aby sprawdzić, czy plik manifestu prywatności został dołączony, i sprawdzić jego zawartość, utwórz archiwum aplikacji i wygeneruj raport o ochronie 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. Do autoryzowania i uwierzytelniania tych żądań, Driver SDK wywołuje obiekt zgodne z protokołem GMTDAuthorization. Obiekt jest odpowiedzialny za przez podanie wymaganego tokena dostępu.

    Jako deweloper aplikacji możesz wybrać sposób generowania tokenów. Twoja implementacja powinien umożliwiać:

    • 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 sekcji Tworzenie Token internetowy JSON (JWT) dla autoryzacji.

    Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Zobacz Fleet Engine Krótkie wprowadzenie Przewodnik .

    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 uzyskać instancję GMTDVehicleReporter, musisz najpierw utworzyć GMTDRidesharingDriverAPI instancję za pomocą identyfikatora dostawcy, pola pojazdówID, driveContext i accessTokenProvider. Identyfikator dostawcy jest taki sam jak w Google. Identyfikator projektu Cloud. Dostęp do instancji GMTDVehicleReporter możesz uzyskać z poziomu bezpośrednio 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 – true. W odpowiedzi na te okresowe aktualizacje obiekt może subskrybować zdarzenia GMTDVehicleReporter przez dostosowanie protokół GMTDVehicleReporterListener.

    Możesz obsługiwać te zdarzenia:

    • vehicleReporter(_:didSucceed:)

      Informuje aplikację sterownika, że usługi backendu otrzymały informacje o lokalizacji i stanie pojazdu.

    • vehicleReporter(_:didFail:withError:)

      Informują detektora o niepowodzeniu aktualizacji pojazdu. Dopóki lokalizacja śledzenie 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 GMSRoadSnappedLocationProvider

    Aby przekazywać aktualizacje lokalizacji do pakietu Driver SDK, GMTDVehicleReporter musi być ustawiony jako detektor elementu 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, aplikacja może mieć ustawienie locationTrackingEnabled na true w: GMTDVehicleReporter. GMTDVehicleReporter wysyła automatycznie aktualizacje lokalizacji. Gdy usługi się zgadzają i przypiszą pojazd do podróży, GMTDVehicleReporter wysyła aktualizacje trasy automatycznie, gdy GMSNavigator jest w trybie nawigacji (gdy miejsce docelowe jest ustawione za pomocą setDestinations).

    Trasa ustawiona podczas aktualizacji trasy będzie taka sama, jak trasa kierowcy przejście do adresu podczas sesji nawigacji. Aby dzielenie się podróżami działało punkt pośredni ustawiony przez setDestinations powinien być taki sam jak miejsce docelowe ustawione w backendzie Fleet Engine.

    Jeśli zasada locationTrackingEnabled ma wartość true, informacje o podróży i pojazdach 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 do Fleet Engine wysyłane jest ostateczne żądanie aktualizacji pojazdu aby ustawić stan pojazdu na GMTDVehicleState.offline. Zobacz updateVehicleState ze szczególnymi informacjami na temat obsługi awarii, gdy locationTrackingEnabled ma wartość false.

    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 to 10 sekund, ale interwał raportowania może zostanie zmieniony przez locationUpdateInterval. Minimalny obsługiwany interwał aktualizacji wynosi 5 sekund. Maksymalny obsługiwany interwał aktualizacji to 60 sekund. Częściej mogą spowalniać przesyłanie żądań i błędów.

    Zaktualizuj stan pojazdu

    Przykład poniżej pokazuje, jak ustawić stan pojazdu na ONLINE. Zobacz 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 on dla 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 włącz pojazd offline

    Aplikacja może wyłączyć aktualizacje i przełączyć pojazd w tryb offline. Na przykład, gdy plik kończy się czas zmiany kierowcy, aplikacja może ustawić: locationTrackingEnabled na: false. Wyłączenie aktualizacji ustawia też stan pojazdu na OFFLINE we Fleet Engine z backendem.

    Swift

    vehicleReporter.locationTrackingEnabled = false

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;