Puoi utilizzare l'SDK Driver per fornire funzionalità di navigazione e monitoraggio avanzate al tuo Richiesta di avanzamento del viaggio e dell'ordine. L'SDK Driver fornisce il controllo aggiornamenti su posizione e attività del parco risorse On-demand Rides and Deliveries Solution Fleet Engine.
L'SDK Driver tiene al corrente i servizi Fleet Engine e i servizi personalizzati
la posizione e lo stato del veicolo. Ad esempio, il veicolo può essere ONLINE
o
OFFLINE
e la posizione del veicolo cambia man mano che la corsa prosegue.
Requisiti minimi di sistema
Prerequisiti
Questa guida presuppone che la tua app implementi già l'opzione Navigazione SDK e che il Fleet Motore il backend è configurato e disponibile. Tuttavia, il codice di esempio fornisce un esempio come configurare l'SDK di navigazione.
Devi anche attivare l'SDK Maps per iOS nel tuo progetto Google Cloud e ricevi un'API Chiave.
Configurazione progetto
Gestore pacchetti Swift
L'SDK Driver può essere installato tramite Gestore pacchetti Swift. Per aggiungere l'SDK, assicurati di avere rimosso eventuali dipendenze esistenti dell'SDK del driver.
Per aggiungere l'SDK a un progetto nuovo o esistente:
-
Apri il file Xcode
project
oworkspace
, quindi seleziona File > Aggiungi dipendenze pacchetto. - Inserisci https://github.com/googlemaps/ios-driver-sdk come URL e premi Invio per estrarre il pacchetto e fai clic su "Aggiungi pacchetto".
-
Per installare un'entità
version
specifica, imposta il campo Regola di dipendenza su uno dei le opzioni basate sulla versione. Per i nuovi progetti, ti consigliamo di specificare la versione più recente con la "versione esatta" . Al termine, fai clic su "Aggiungi pacchetto". -
Nella finestra Scegli i prodotti del pacchetto, verifica che verrà aggiunto
GoogleRidesharingDriver
il targetmain
designato. Al termine, fai clic su "Aggiungi pacchetto". -
Per verificare l'installazione, vai al riquadro
General
di destinazione. In Framework, librerie e contenuti incorporati dovresti vedere i pacchetti installati. Puoi anche visualizzare le "Dipendenze pacchetto" sezione di "Project Navigator" per verificare il pacchetto e la sua versione.
Per aggiornare package
per un progetto esistente:
Se esegui l'upgrade da una versione precedente alla 9.0.0, devi rimuovere le dipendenze seguenti:
GoogleMapsBase
,GoogleMapsCore
eGoogleMapsM4B
dopo l'upgrade. Non rimuovere la dipendenza perGoogleMaps
. Per ulteriori informazioni, consulta Note di rilascio della versione 9.0.0.Dalle impostazioni di configurazione del progetto Xcode, individua Framework, Libraries, e Contenuti incorporati. Utilizza il segno meno(-) per rimuovere il seguente framework:
GoogleMapsBase
(solo per gli upgrade da versioni precedenti alla 9.0.0)GoogleMapsCore
(solo per gli upgrade da versioni precedenti alla 9.0.0)GoogleMapsM4B
(solo per gli upgrade da versioni precedenti alla 9.0.0)
- Da Xcode, vai su "File > Pacchetti > Aggiorna alle ultime versioni del pacchetto".
- Per verificare l'installazione, vai alla sezione Dipendenze pacchetto di Project Navigator per verificare il pacchetto e la sua versione.
Per rimuovere le dipendenze esistenti dell'SDK del driver aggiunte utilizzando
CocoaPods
, segui questi passaggi:
- Chiudi l'area di lavoro Xcode. Apri il terminale ed esegui questo comando:
sudo gem install cocoapods-deintegrate cocoapods-clean pod deintegrate pod cache clean --all
-
Rimuovi
Podfile
,Podfile.resolved
e Esegui l'Xcodeworkspace
se non lo utilizzi per scopi diversi da CocoaPods.
Per rimuovere l'SDK del driver esistente installato manualmente, segui questi passaggi:
Dalle impostazioni di configurazione del tuo progetto Xcode, individua Frameworks, Librerie e contenuti incorporati. Utilizza il segno meno
(-)
per rimuovere l'elemento. il seguente framework:GoogleRidesharingDriver.xcframework
Dalla directory di primo livello del tuo progetto Xcode, rimuovi Set
GoogleRidesharingDriver
.
CocoaPods
Per configurare l'SDK Driver utilizzando CocoaPods, sono necessari i seguenti elementi:
- Lo strumento CocoaPods: per installare lo strumento, apri il terminale ed esegui .
sudo gem install cocoapods
Creare un podfile per l'SDK Driver e utilizzarlo per installare l'API e e le sue dipendenze: crea un file denominato Podfile nella directory del progetto. Questo file definisce le dipendenze del progetto. Modifica il podfile e aggiungi le tue dipendenze. Ecco un esempio che include le dipendenze:
source "https://github.com/CocoaPods/Specs.git" target 'YOUR_APPLICATION_TARGET_NAME_HERE' do pod 'GoogleRidesharingDriver' end
Ecco un esempio che include i pod Alpha e Beta per SDK driver come dipendenze:
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
Salva il podfile. Apri un terminale e vai alla directory contenente Podfile:
cd <path-to-project>
Esegui il comando di installazione dei pod. Questa operazione installerà le API specificate nel di pod, insieme alle eventuali dipendenze.
pod install
Chiudi Xcode, quindi apri (fai doppio clic) nell'area di lavoro .xcworkspace del tuo progetto per avviare Xcode. D'ora in poi, dovrai utilizzare .xcworkspace per aprire il progetto.
Fai riferimento alla guida introduttiva di CocoaPods guida per saperne di più i dettagli.
Installazione manuale
Un XCFramework è un pacchetto binario che puoi usare per installare SDK driver. Puoi utilizzare questo pacchetto su più di Google Cloud, incluse le macchine che utilizzano Apple al silicio. Questa guida illustra come aggiungere manualmente l'XCFramework contenente Driver SDK nel progetto e configura la build impostazioni in Xcode.
Scarica il file binario e le risorse dell'SDK:
Estrai i file per accedere a XCFramework e alle risorse.
Avvia Xcode e apri un progetto esistente o creane uno nuovo progetto. Se è la prima volta che utilizzi iOS, crea un nuovo progetto e seleziona l'icona Modello di app.
Creare un gruppo Framework nel gruppo di progetto se non ne esiste uno .
Per installare l'SDK dei driver, trascina
GoogleRidesharingDriver.xcframework
nel tuo progetto in Framework, librerie e contenuti incorporati. Quando richiesto, seleziona Copia gli elementi, se necessario.Trascina l'elemento
GoogleRidesharingDriver.bundle
scaricato in primo livello del tuo progetto Xcode. Quando richiesto, selezionaCopy items if needed
.Seleziona il tuo progetto dal navigatore dei progetti e scegli target dell'applicazione.
Apri la scheda Fasi di creazione e in Collega binario con le librerie aggiungi i seguenti framework e librerie, se non sono già presenti:
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
Scegli il tuo progetto, anziché un target specifico, e apri lo strumento Crea Impostazioni. Nella sezione Altri flag linker, aggiungi
-ObjC
per sia di debug che di release. Se queste impostazioni non sono visibili, modifica nella barra delle impostazioni della build da Di base a Tutte.
Ispeziona il file manifest della privacy di Apple
Apple richiede informazioni sulla privacy per le app disponibili sull'App Store. Visita la pagina dei dettagli sulla privacy dell'App Store di Apple per aggiornamenti e ulteriori informazioni.
Il file manifest della privacy di Apple è incluso nel bundle di risorse per l'SDK. Per verificare che il file manifest per la privacy sia stato incluso e per controllarne i contenuti, crea un archivio della tua app e genera una segnalazione sulla privacy dall'archivio.
Implementare l'autorizzazione e l'autenticazione
Quando l'app Driver genera e invia aggiornamenti al backend Fleet Engine,
le richieste devono includere token di accesso validi. Per autorizzare e autenticare
queste richieste, l'SDK del driver chiama il tuo oggetto
conforme al protocollo GMTDAuthorization
. L'oggetto è responsabile
fornendo il token di accesso richiesto.
In qualità di sviluppatore dell'app, sei tu a scegliere il modo in cui vengono generati i token. La tua implementazione dovrebbe offrire la possibilità di:
- Recupera un token di accesso, possibilmente in formato JSON, da un server HTTPS.
- Analizza e memorizza nella cache il token.
- Aggiorna il token alla scadenza.
Per maggiori dettagli sui token previsti dal server Fleet Engine, consulta la sezione Creazione di un JSON Web Token (JWT) per autorizzazione.
L'ID provider corrisponde all'ID progetto Google Cloud. Vedi Motore del parco risorse Guida rapida Guida per ulteriori informazioni.
L'esempio seguente implementa un provider di token di accesso:
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
Crea un'istanza RidesharingDriverAPI
Per ottenere un'istanza GMTDVehicleReporter
, devi prima creare un'istanza
Istanza GMTDRidesharingDriverAPI
utilizzando providerID, VehicleID,
driverContext e accessTokenProvider. Il provider ID è uguale a quello di Google
dell'ID progetto Cloud. Puoi anche accedere all'istanza GMTDVehicleReporter
dalla
direttamente l'API driver.
L'esempio seguente crea un'istanza 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];
}
Facoltativamente, ascolta gli eventi di VehicleReporter
GMTDVehicleReporter
aggiorna periodicamente il veicolo quando
locationTrackingEnabled
è true
. Per rispondere a questi aggiornamenti periodici, qualsiasi
può iscriversi a GMTDVehicleReporter
eventi rispettando le
il protocollo GMTDVehicleReporterListener
.
Puoi gestire i seguenti eventi:
vehicleReporter(_:didSucceed:)
Informa l'app driver che i servizi di backend hanno ricevuto correttamente il aggiornamento della posizione e dello stato del veicolo.
vehicleReporter(_:didFail:withError:)
Informa il listener che un aggiornamento del veicolo non è riuscito. A condizione che la posizione il monitoraggio è attivato,
GMTDVehicleReporter
continua a inviare i dati più recenti al backend di Fleet Engine.
Nell'esempio seguente vengono gestiti questi eventi:
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
Aggiungi GMTDVeicoliReporter come listener a GMSRoadSnappedLocationProvider
Per fornire aggiornamenti sulla posizione all'SDK dei driver, GMTDVehicleReporter
deve essere impostato come listener per 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
Attiva il monitoraggio della posizione
Per attivare il monitoraggio della posizione, la tua app può impostare locationTrackingEnabled
su
true
su GMTDVehicleReporter
. GMTDVehicleReporter
invia automaticamente
aggiornamenti posizione. Dopo che i servizi corrispondono e hanno assegnato il veicolo a una corsa,
GMTDVehicleReporter
invia automaticamente aggiornamenti sul percorso quando GMSNavigator
è in modalità di navigazione (quando una destinazione è impostata tramite setDestinations
).
Il percorso impostato durante l'aggiornamento della corsa sarà lo stesso del conducente.
durante la sessione di navigazione. Quindi, per condividere il percorso di lavoro
correttamente, il waypoint impostato tramite setDestinations
deve corrispondere
impostata nel backend di Fleet Engine.
Se il criterio locationTrackingEnabled
è impostato su true
, vengono inviati aggiornamenti sul percorso e sul veicolo
al backend Fleet Engine a intervalli regolari in base al valore impostato
locationUpdateInterval
. Se il criterio locationTrackingEnabled
viene impostato su false
,
gli aggiornamenti si interrompono e viene inviata una richiesta di aggiornamento finale del veicolo a Fleet Engine
per impostare lo stato del veicolo su GMTDVehicleState.offline
. Consulta
updateVehicleState
per considerazioni speciali sulla gestione degli errori quando locationTrackingEnabled
è impostato su false
.
Il seguente esempio abilita il monitoraggio della posizione:
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
Per impostazione predefinita, l'intervallo di report è di 10 secondi, ma può
da modificare con locationUpdateInterval
. L'intervallo di aggiornamento minimo supportato
è di 5 secondi. L'intervallo di aggiornamento massimo supportato è di 60 secondi. Più frequente
degli aggiornamenti, le richieste e gli errori potrebbero essere più lenti.
Aggiorna lo stato del veicolo
L'esempio seguente mostra come impostare lo stato del veicolo su ONLINE
. Consulta
updateVehicleState
per maggiori dettagli.
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
Quando la maschera è vuota, può verificarsi un errore update_mask
, che si verifica generalmente
per il primo aggiornamento dopo l'avvio. L'esempio seguente mostra come gestire
questo errore:
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
Disattiva gli aggiornamenti sulla posizione e metti offline il veicolo
La tua app può disattivare gli aggiornamenti e mettere offline il veicolo. Ad esempio, quando
il turno del conducente termina, la tua app può impostare locationTrackingEnabled
su false
.
La disattivazione degli aggiornamenti imposta anche lo stato del veicolo su OFFLINE
su Fleet Engine
di un backend cloud.
Swift
vehicleReporter.locationTrackingEnabled = false
Objective-C
_vehicleReporter.locationTrackingEnabled = NO;