Możesz użyć pakietu SDK sterownika, aby zapewnić lepszą nawigację i śledzenie w aplikacjach Podróż i Postępy zamówień. Pakiet SDK Driver SDK zapewnia aktualizacje lokalizacji pojazdów i zadań w rozwiązaniu Fleet Engine usługi On-demand and Deliveries Solution Fleet Engine.
Pakiet Driver SDK informuje usługi Fleet Engine i usługi niestandardowe o lokalizacji i stanie pojazdu. Na przykład pojazd może mieć wartość ONLINE
lub OFFLINE
, a lokalizacja pojazdu 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 oraz że backend Fleet Engine jest skonfigurowany i dostępny. Ten przykładowy kod pokazuje jednak, jak skonfigurować pakiet SDK nawigacji.
Musisz też włączyć w projekcie Google Cloud pakiet SDK Map Google na iOS i uzyskać klucz interfejsu API.
Konfiguracja projektu
Możesz skonfigurować pakiet SDK sterownika za pomocą CocoaPods.
Korzystanie z CocoaPods
Aby skonfigurować pakiet SDK sterownika przy użyciu 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 Driver SDK i użyj go do zainstalowania interfejsu API i jego zależności. Utwórz plik Podfile w katalogu projektu. Ten plik definiuje zależności projektu. Edytuj plik Podfile i dodaj zależności. Oto przykład, który przedstawia zależności:
source "https://github.com/CocoaPods/Specs.git" target 'YOUR_APPLICATION_TARGET_NAME_HERE' do pod 'GoogleRidesharingDriver' end
Oto przykład, w którym pody w wersji alfa i beta na potrzeby pakietu SDK sterownika są zależnościami:
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 Podfile:
cd <path-to-project>
Uruchom polecenie instalacji poda. Spowoduje to zainstalowanie interfejsów API określonych w pliku Podfile oraz wszystkich zależności.
pod install
Zamknij Xcode, a następnie kliknij (dwukrotnie) plik .xcworkspace projektu, aby uruchomić Xcode. Od tej pory projekt można otwierać tylko za pomocą pliku .xcworkspace.
Instalowanie XCFramework
XCFramework to pakiet binarny służący do instalacji pakietu Driver SDK. Możesz używać tego pakietu na wielu platformach, w tym na maszynach korzystających z Apple Silicon. Ten przewodnik pokazuje, jak ręcznie dodać do projektu komponent XCFramework zawierający pakiet SDK Driver 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 Aplikacja na iOS.
Utwórz w grupie projektów grupę Platformy, jeśli jeszcze jej nie ma.
Przeciągnij plik
gRPCCertificates.bundle
znajdujący się z kataloguResources
w pliku ZIP zawierającym XCFramework do katalogu najwyższego poziomu projektu Xcode. Gdy pojawi się prośba, w razie potrzeby wybierz Kopiuj elementy.Aby zainstalować pakiet SDK Driver, przeciągnij plik
GoogleRidesharingDriver.xcframework
do projektu podFrameworks, Libraries, and Embedded Content
. Gdy pojawi się prośba, w razie potrzeby wybierz Kopiuj elementy.Kliknij prawym przyciskiem myszy
GoogleRidesharingDriver.xcframework
w projekcie i wybierzShow In Finder
.Przeciągnij
GoogleRidesharingDriver.bundle
z folderuios-arm64_x86_64-simulator/GoogleRidesharingDriver.framework/Resources
do katalogu najwyższego poziomu projektu Xcode. Gdy pojawi się komunikat, upewnij się, że poleCopy items if needed
nie jest zaznaczone.Wybierz projekt w nawigatorze projektów i 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, a nie konkretny cel, i otwórz kartę Ustawienia kompilacji. W sekcji Inne oznaczenia łączące dodaj parametr
‑ObjC
na potrzeby debugowania i publikowania. Jeśli te ustawienia nie są widoczne, zmień filtr na pasku ustawień kompilacji z Podstawowe na Wszystkie.
Wersje pakietu SDK (alfa i beta)
Aby skonfigurować wersję alfa lub beta pakietu Driver SDK 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 deweloperskie na liście dostępu Google. Repozytorium podów wersji alfa i beta pakietu SDK nie jest publicznym źródłem. Aby uzyskać dostęp do tych wersji, skontaktuj się z inżynierem Google ds. obsługi klienta. Inżynier dodaje Twoje konto dewelopera do listy dostępu, a potem ustawia plik cookie do uwierzytelniania.
Gdy projekt znajdzie się na liście dostępu, uzyskasz dostęp do poda.
Utwórz plik Podfile dla pakietu SDK Delivery SDK na iOS i użyj go do zainstalowania interfejsu API i 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 zależności. Oto przykład, który przedstawia 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 zawierającego Podfile:
cd <path-to-project>
Uruchom polecenie instalacji poda. Polecenie to instaluje interfejsy API określone w pliku Podfile oraz wszystkie zależności, jakie mogą mieć.
pod install
Zamknij Xcode, a następnie kliknij (dwukrotnie) plik .xcworkspace projektu, aby uruchomić Xcode. Od tej pory projekt można otwierać tylko za pomocą pliku .xcworkspace.
Wdrażanie autoryzacji i uwierzytelniania
Gdy aplikacja sterownika generuje i wysyła aktualizacje do backendu Fleet Engine, żądania muszą zawierać prawidłowe tokeny dostępu. Aby autoryzować i uwierzytelnić te żądania, pakiet SDK sterownika wywołuje Twój obiekt zgodnie z protokołem GMTDAuthorization
. Obiekt jest odpowiedzialny za udostępnienie wymaganego tokena dostępu.
Jako deweloper aplikacji decydujesz o sposobie generowania tokenów. Twoja implementacja powinna pozwalać na:
- Pobierz token dostępu (na przykład w formacie JSON) z serwera HTTPS.
- Przeanalizuj token i zapisz go w pamięci podręcznej.
- Odśwież token, gdy straci ważność.
Informacje o tokenach oczekiwanych przez serwer Fleet Engine znajdziesz w artykule o tworzeniu tokena internetowego JSON (JWT) do autoryzacji.
Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Więcej informacji znajdziesz w krótkim wprowadzeniu do Fleet Engine.
W poniższym przykładzie implementowano dostawcę tokenów 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 identyfikatorów providerID, vehicleID, sterownikContext i accessTokenProvider. Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Dostęp do instancji GMTDVehicleReporter
możesz uzyskać 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łuchuj zdarzeń VehicleReporter
GMTDVehicleReporter
okresowo aktualizuje pojazd, gdy locationTrackingEnabled
ma wartość true
. Aby zareagować na te okresowe aktualizacje, dowolny obiekt może subskrybować zdarzenia GMTDVehicleReporter
zgodnie z protokołem GMTDVehicleReporterListener
.
Możesz obsługiwać te zdarzenia:
vehicleReporter(_:didSucceed:)
Informuje aplikację sterownika, że usługi backendu pomyślnie otrzymały aktualizację lokalizacji i stanu pojazdu.
vehicleReporter(_:didFail:withError:)
Informuje detektor o niepowodzeniu aktualizacji pojazdu. Dopóki śledzenie lokalizacji jest włączone,
GMTDVehicleReporter
będzie 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 aktualizować lokalizację w pakiecie SDK sterownika, GMTDVehicleReporter
musi być ustawiony jako detektor GMSRoadSnappedLocationProvider
.
Swift
import GoogleRidesharingDriver
private let providerID = "INSERT_YOUR_PROVIDER_ID"
class SampleViewController: UIViewController, GMTDVehicleReporterListener {
private let mapView: GMSMapView
override func viewDidLoad() {
// Assumes you have implemented the sample code up to this step.
if let roadSnappedLocationProvider = mapView.roadSnappedLocationProvider {
roadSnappedLocationProvider.add(ridesharingDriverAPI.vehicleReporter)
roadSnappedLocationProvider.startUpdatingLocation()
}
}
}
Objective-C
/*
* SampleViewController.h
*/
@interface SampleViewController : UIViewController<GMTDVehicleReporterListener>
@end
/*
* SampleViewController.m
*/
#import "SampleViewController.h"
#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";
@implementation SampleViewController {
GMSMapView *_mapView;
}
- (void)viewDidLoad {
// Assumes you have implemented the sample code up to this step.
[_mapView.roadSnappedLocationProvider addListener:ridesharingDriverAPI.vehicleReporter];
[_mapView.roadSnappedLocationProvider startUpdatingLocation];
}
@end
Włącz śledzenie lokalizacji
Aby włączyć śledzenie lokalizacji, aplikacja może ustawić locationTrackingEnabled
na true
w dniu GMTDVehicleReporter
. GMTDVehicleReporter
automatycznie wysyła aktualizacje lokalizacji.
Gdy usługi dopasują się i przypiszą pojazd do podróży, GMTDVehicleReporter
automatycznie wysyła aktualizacje trasy, gdy GMSNavigator
działa w trybie nawigacji (gdy miejsce docelowe jest ustawione na setDestinations
).
Trasa ustawiona podczas aktualizacji podróży będzie tą samą trasą, którą pokonuje kierowca podczas sesji nawigacji.
Aby udostępnianie przejazdów działało prawidłowo, punkt pośredni ustawiony przez setDestinations
powinien być zgodny z miejscem docelowym ustawionym w backendzie Fleet Engine.
Jeśli zasada locationTrackingEnabled
ma wartość true
, aktualizacje dotyczące podróży i pojazdu są wysyłane do backendu Fleet Engine w regularnych odstępach czasu na podstawie wartości ustawionej w locationUpdateInterval
. Jeśli locationTrackingEnabled
ma wartość false
, aktualizacje są zatrzymywane, a końcowe żądanie aktualizacji pojazdu jest wysyłane do backendu Fleet Engine w celu ustawienia stanu pojazdu na GMTDVehicleState.offline
.
W sekcji updateVehicleState
znajdziesz specjalne uwagi dotyczące obsługi błędów, gdy parametr locationTrackingEnabled
ma wartość false
.
Ten 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ślna długość okresu raportowania wynosi 10 sekund, ale można go zmienić za pomocą funkcji locationUpdateInterval
. Minimalny obsługiwany interwał aktualizacji
to 5 sekund. Maksymalny obsługiwany interwał aktualizacji to 60 sekund. Częstsze aktualizacje mogą powodować wolniejsze przesyłanie żądań i błędy.
Zaktualizuj stan pojazdu
Z przykładu poniżej dowiesz się, 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
i zwykle występuje on podczas 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 w tryb offline
Aplikacja może wyłączyć aktualizacje i przełączyć pojazd w tryb offline. Na przykład: gdy kończy się zmiana kierowcy, aplikacja może ustawić locationTrackingEnabled
na false
. Wyłączenie aktualizacji spowoduje też ustawienie stanu pojazdu na OFFLINE
w backendzie Fleet Engine.
Swift
vehicleReporter.locationTrackingEnabled = false
Objective-C
_vehicleReporter.locationTrackingEnabled = NO;