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
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:
-
Otwórz
project
lubworkspace
Xcode, a następnie wybierz File > Add Package Dependencies (Plik > Dodaj zależności pakietu). - Jako URL wpisz https://github.com/googlemaps/ios-driver-sdk, naciśnij Enter, aby pobrać pakiet, i kliknij „Dodaj pakiet”.
-
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”. -
W oknie Wybierz produkty w pakiecie sprawdź, czy
GoogleRidesharingDriver
zostanie dodany do wyznaczonegomain
celu. Gdy skończysz, kliknij „Dodaj pakiet”. -
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:
Jeśli uaktualniasz aplikację z wersji wcześniejszej niż 9.0.0, po uaktualnieniu musisz usunąć te zależności:
GoogleMapsBase
,GoogleMapsCore
iGoogleMapsM4B
. 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)
- W Xcode wybierz „File > Packages > Update to Latest Package Versions” (Plik > Pakiety> Aktualizuj do najnowszych wersji pakietu).
- 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:
- Zamknij obszar roboczy Xcode. Otwórz terminal i wykonaj to polecenie:
sudo gem install cocoapods-deintegrate cocoapods-clean pod deintegrate pod cache clean --all
-
Usuń
Podfile
,Podfile.resolved
i Xcodeworkspace
, jeśli nie używasz ich do niczego innego niż CocoaPods.
Aby ręcznie usunąć zainstalowany pakiet Driver SDK, wykonaj te czynności:
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
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
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
Zapisz plik Podfile. Otwórz terminal i przejdź do katalogu zawierającego plik Podfile:
cd <path-to-project>
Uruchom polecenie instalacji poda. Spowoduje to zainstalowanie interfejsów API określonych w pliku Podfile wraz ze wszystkimi ich zależnościami.
pod install
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:
Rozpakuj pliki, aby uzyskać dostęp do XCFramework i zasobów.
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.
Jeśli grupa projektów jeszcze nie istnieje, utwórz w niej grupę projektów.
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.Przeciągnij pobrany plik
GoogleRidesharingDriver.bundle
do katalogu najwyższego poziomu w projekcie Xcode. Gdy pojawi się odpowiedni komunikat, wybierzCopy items if needed
.Wybierz projekt w narzędziu Project Navigator, a potem wskaż miejsce docelowe aplikacji.
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
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.
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. 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;