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
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:
- Narzędzie CocoaPods: aby zainstalować to narzędzie, otwórz Terminal i uruchom to polecenie.
shell sudo gem install cocoapods
Więcej informacji znajdziesz w przewodniku dla początkujących na temat CocoaPods.
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
Zapisz plik Podfile. Otwórz terminal i przejdź do katalogu z plikiem Podfile:
cd <path-to-project>
Uruchom polecenie instalacji poda. Spowoduje to zainstalowanie interfejsów API określonych w pliku Podfile wraz z ich zależnościami.
pod install
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.
Rozpakuj pliki źródłowe otrzymane od Google.
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 jeszcze nie istnieje, utwórz grupę w ramach grupy projektów.
Przeciągnij plik
gRPCCertificates.bundle
znajdujący się w kataloguResources
archiwum ZIP zawierającego element XCFramework do katalogu najwyższego poziomu w projekcie Xcode. W razie potrzeby wybierz Kopiuj elementy.Aby zainstalować pakiet SDK Driver, przeciągnij plik
GoogleRidesharingDriver.xcframework
do projektu:Frameworks, Libraries, and Embedded Content
W razie potrzeby wybierz Kopiuj elementy.Wybierz projekt w Nawigatorze projektu i wybierz aplikację.
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
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.
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
Zapisz plik Podfile. Otwórz terminal i przejdź do katalogu z plikiem Podfile:
cd <path-to-project>
Uruchom polecenie instalacji poda. To polecenie instaluje interfejsy API określone w Podfile wraz z ich zależnościami.
pod install
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;