Creare e visualizzare un viaggio con una sola destinazione

Questo tutorial illustra la procedura per creare un viaggio con un singolo ritiro e consegna e quindi condividere il percorso con un consumatore.

Prerequisiti

Per completare questo tutorial, assicurati di svolgere le seguenti operazioni:

1. Configurare Fleet Engine. Per ulteriori informazioni, consulta Fleet Engine: configurazione iniziale.

2. Integra la tua app con l'SDK Driver. Per maggiori informazioni, consulta Inizializzazione dell'SDK Driver per Android e Guida all'integrazione per l'SDK Driver per iOS.

3. Integra la tua app rivolta ai consumatori con l'SDK consumer. Per ulteriori informazioni, consulta la Guida introduttiva all'SDK per i consumatori per Android e la Guida introduttiva all'SDK per i consumatori per iOS.

4. Configurare i token di autorizzazione. Per ulteriori informazioni sui token di autorizzazione, consulta Creazione di un token web JSON per l'autorizzazione nella guida Introduzione a Fleet Engine e Autenticazione e autorizzazione nella documentazione dell'SDK consumer per Fleet Engine.

Passaggio 1: Crea un veicolo in Fleet Engine

I veicoli sono oggetti che rappresentano i veicoli della tua flotta. Devi crearle in Fleet Engine per poterli monitorare nell'app consumer.

Puoi creare un veicolo seguendo uno dei due approcci seguenti:

gRPC

Chiama il metodo CreateVehicle() con il messaggio di richiesta CreateVehicleRequest. Devi disporre dei privilegi di super user Fleet Engine per chiamare CreateVehicle().

REST

Chiama il numero https://fleetengine.googleapis.com/v1/providers.vehicles.create.

Avvertenze

Durante la creazione di un veicolo, si applicano le seguenti avvertenze.

• Assicurati di impostare lo stato iniziale del veicolo su OFFLINE. In questo modo, Fleet Engine può rilevare il tuo veicolo per la corrispondenza della corsa.

• Il valore provider_id del veicolo deve corrispondere all'ID del progetto Google Cloud che contiene gli account di servizio utilizzati per chiamare Fleet Engine. Sebbene più account di servizio possano accedere a Fleet Engine per lo stesso provider di ridesharing, attualmente Fleet Engine non supporta gli account di servizio di diversi progetti Google Cloud che accedono agli stessi veicoli.

• La risposta restituita da CreateVehicle() contiene l'istanza Vehicle. L'istanza viene eliminata dopo sette giorni se non è stata aggiornata utilizzando UpdateVehicle(). Devi chiamare GetVehicle() prima di chiamare CreateVehicle() per verificare che il veicolo non esista già. Se GetVehicle() restituisce un errore NOT_FOUND, devi procedere con la chiamata a CreateVehicle(). Per saperne di più, consulta Veicoli e loro ciclo di vita.

Esempio

Il seguente esempio di codice del provider mostra come creare un veicolo in Fleet Engine.

static final String PROJECT_ID = "my-rideshare-co-gcp-project";

VehicleServiceBlockingStub vehicleService = VehicleService.newBlockingStub(channel);

String parent = "providers/" + PROJECT_ID;

Vehicle vehicle = Vehicle.newBuilder()
    .setVehicleState(VehicleState.OFFLINE)  // Initial state
    .addSupportedTripTypes(TripType.EXCLUSIVE)
    .setMaximumCapacity(4)
    .setVehicleType(VehicleType.newBuilder().setCategory(VehicleType.Category.AUTO))
    .build();

CreateVehicleRequest createVehicleRequest = CreateVehicleRequest.newBuilder()
    .setParent(parent)
    .setVehicleId("8241890")  // Vehicle ID assigned by solution provider.
    .setVehicle(vehicle)      // Initial state.
    .build();

// The Vehicle is created in the OFFLINE state, and no initial position is
// provided.  When the driver app calls the rideshare provider, the state can be
// set to ONLINE, and the driver app updates the vehicle location.
try {
  Vehicle createdVehicle = vehicleService.createVehicle(createVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
    case ALREADY_EXISTS:
      break;
    case PERMISSION_DENIED:
      break;
  }
  return;
}

Passaggio 2: Attiva il monitoraggio della posizione

Il monitoraggio della posizione si riferisce al monitoraggio della posizione del veicolo durante il viaggio, in cui l'app del conducente invia dati di telemetria a Fleet Engine, che contiene la posizione attuale del veicolo. Questo flusso di informazioni sulla posizione costantemente aggiornato viene utilizzato per comunicare lo stato di avanzamento del veicolo lungo il percorso. Quando attivi il monitoraggio della posizione, l'app del conducente inizia a inviare questa telemetria con una frequenza predefinita di una volta ogni cinque secondi.

Per abilitare il monitoraggio della posizione per Android e iOS:

• Chiama il metodo SDK Driver per Android enableLocationTracking().

• Imposta l'SDK Driver per la proprietà booleana per iOS locationTrackingEnabled su true.

Nota: l'autenticazione delle chiamate all'SDK Driver per le API Android richiede un token di autenticazione che utilizzi il ruolo "Driver" e che includa un vehicle_id.

Esempio

Il seguente esempio di codice mostra come attivare il monitoraggio della posizione.

Java

RidesharingVehicleReporter vehicleReporter = ...;

vehicleReporter.enableLocationTracking();

Kotlin

val vehicleReporter = ...

vehicleReporter.enableLocationTracking()

Swift

vehicleReporter.locationTrackingEnabled = true

Objective-C

_vehicleReporter.locationTrackingEnabled = YES;

Passaggio 3: Impostare lo stato del veicolo su online

Metti un veicolo in servizio (ovvero, per renderlo disponibile all'uso) impostandone lo stato su online, ma non potrai farlo finché non avrai attivato il monitoraggio della posizione.

Per impostare lo stato del veicolo su Online per Android e iOS:

• Chiama il metodo SDK Driver per Android setVehicleState(VehicleState.ONLINE).

• Chiama l'SDK Driver per iOS vehicleReporter.update(.online).

Esempio

Il seguente esempio di codice mostra come impostare lo stato del veicolo su ONLINE.

Java

vehicleReporter.setVehicleState(VehicleState.ONLINE);

Kotlin

vehicleReporter.setVehicleState(VehicleState.ONLINE)

Swift

vehicleReporter.update(.online)

Objective-C

[_vehicleReporter updateVehicleState:GMTDVehicleStateOnline];

Passaggio 4: Crea una corsa in Fleet Engine

A livello di programmazione, un Trip è un oggetto che rappresenta un viaggio e devi crearne uno per ogni richiesta di viaggio in modo che possa essere abbinata a veicoli e poi monitorati.

• Puoi creare un viaggio chiamando il metodo CreateTrip() con il messaggio di richiesta CreateTripRequest.

Attributi obbligatori

I seguenti campi sono obbligatori per creare una corsa.

parent

Una stringa che include l'ID provider. Deve essere uguale all'ID del progetto Google Cloud che contiene gli account di servizio utilizzati per chiamare Fleet Engine

trip_id

Una stringa creata da te che identifica in modo univoco questo viaggio.

trip_type

Uno dei valori di enumerazione di TripType (SHARED o EXCLUSIVE).

pickup_point

Il punto di partenza della corsa.

Quando crei una corsa, puoi specificare i campi number_of_passengers, dropoff_point e vehicle_id, anche se questi campi non sono obbligatori. Se fornisci un vehicle_id, la corsa contiene un elenco dei waypoint rimanenti, che puoi utilizzare per impostare la destinazione nell'app del conducente.

Nota: per utilizzare CreateTrip() sono necessarie le credenziali dell'account con privilegi menzionato in Fleet Engine: Initial setup.

Esempio

L'esempio seguente mostra come creare un viaggio al Grand Indonesia East Mall. Il viaggio è esclusivo e ha due passeggeri, lo stato è nuovo. Il provider_id della corsa deve essere uguale all'ID progetto. Nell'esempio, il provider di ridesharing ha creato il progetto Google Cloud con l'ID progetto my-rideshare-co-gcp-project. Questo progetto deve includere un account di servizio per la chiamata a Fleet Engine.

static final String PROJECT_ID = "my-rideshare-co-gcp-project";

TripServiceBlockingStub tripService = TripService.newBlockingStub(channel);

// Trip initial settings.
String parent = "providers/" + PROJECT_ID;

Trip trip = Trip.newBuilder()
    .setTripType(TripType.EXCLUSIVE) // Use TripType.SHARED for carpooling.
    .setPickupPoint(                 // Grand Indonesia East Mall.
        TerminalLocation.newBuilder().setPoint(
            LatLng.newBuilder()
                .setLatitude(-6.195139).setLongitude(106.820826)))
    .setNumberOfPassengers(2)
    // Provide the drop-off point if available.
    .setDropoffPoint(
        TerminalLocation.newBuilder().setPoint(
            LatLng.newBuilder()
                .setLatitude(-6.1275).setLongitude(106.6537)))
    .build();

// Create trip request
CreateTripRequest createTripRequest = CreateTripRequest.newBuilder()
    .setParent(parent)
    .setTripId("trip-8241890")  // Trip ID assigned by the provider.
    .setTrip(trip)              // The initial state is NEW.
    .build();

// Error handling.
try {
  Trip createdTrip = tripService.createTrip(createTripRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
    case ALREADY_EXISTS:
      break;
    case PERMISSION_DENIED:
      break;
  }
  return;
}

Passaggio 5: Imposta la destinazione nell'app del conducente

Dopo aver associato un consumatore a un autista, devi configurare la destinazione della corsa nell'app del conducente. Puoi recuperare la destinazione del veicolo dalla raccolta dei waypoint, che viene restituita entro i giorni GetTrip(), UpdateTrip() e GetVehicle().

• Per impostare la destinazione, chiama il metodo dell'SDK di navigazione per Android setDestination() o il metodo setDestinations() dell'SDK di navigazione per iOS.

Affinché l'app del consumatore possa visualizzare correttamente la corsa, le coordinate geografiche (LatLng) fornite a setDestination() devono corrispondere a quelle del waypoint della corsa. Per ulteriori informazioni, consulta i tutorial Esegui il routing a una singola destinazione e Esegui il routing a più destinazioni.

Esempio

Il seguente esempio di codice mostra come impostare la destinazione nell'app Driver.

Java

private void navigateToPlace(String placeId, RoutingOptions travelMode) {
  Waypoint destination;
  try {
    destination = Waypoint.fromPlaceId(placeId, null);
  } catch (Waypoint.UnsupportedPlaceIdException e) {
    displayMessage("Error starting navigation: Place ID is not supported.");
    return;
  }

  // Create a future to await the result of the asynchronous navigator task.
  ListenableResultFuture<Navigator.RouteStatus> pendingRoute =
      mNavigator.setDestination(destination, travelMode);

  // Define the action to perform when the SDK has determined the route.
  pendingRoute.setOnResultListener(
      new ListenableResultFuture.OnResultListener<Navigator.RouteStatus>() {
        @Override
        public void onResult(Navigator.RouteStatus code) {
          switch (code) {
            case OK:
              // Hide the toolbar to maximize the navigation UI.
              if (getActionBar() != null) {
                getActionBar().hide();
              }

              // Enable voice audio guidance (through the device speaker).
              mNavigator.setAudioGuidance(
                  Navigator.AudioGuidance.VOICE_ALERTS_AND_GUIDANCE);

              // Simulate vehicle progress along the route for demo/debug builds.
              if (BuildConfig.DEBUG) {
                mNavigator.getSimulator().simulateLocationsAlongExistingRoute(
                    new SimulationOptions().speedMultiplier(5));
              }

              // Start turn-by-turn guidance along the current route.
              mNavigator.startGuidance();
              break;
            // Handle error conditions returned by the navigator.
            case NO_ROUTE_FOUND:
              displayMessage("Error starting navigation: No route found.");
              break;
            case NETWORK_ERROR:
              displayMessage("Error starting navigation: Network error.");
              break;
            case ROUTE_CANCELED:
              displayMessage("Error starting navigation: Route canceled.");
              break;
            default:
              displayMessage("Error starting navigation: "
                  + String.valueOf(code));
          }
        }
      });
}

Kotlin

private fun navigateToPlace(placeId: String, travelMode: RoutingOptions) {
  val destination =
    try {
      Waypoint.fromPlaceId(placeId, null)
    } catch (e: Waypoint.UnsupportedPlaceIdException) {
      displayMessage("Error starting navigation: Place ID is not supported.")
      return@navigateToPlace
    }

  // Create a future to await the result of the asynchronous navigator task.
  val pendingRoute = mNavigator.setDestination(destination, travelMode)

  // Define the action to perform when the SDK has determined the route.
  pendingRoute.setOnResultListener(
    object : ListenableResultFuture.OnResultListener<Navigator.RouteStatus>() {
      override fun onResult(code: Navigator.RouteStatus) {
        when (code) {
          Navigator.RouteStatus.OK -> {
            // Hide the toolbar to maximize the navigation UI.
            getActionBar()?.hide()

            // Enable voice audio guidance (through the device speaker).
            mNavigator.setAudioGuidance(Navigator.AudioGuidance.VOICE_ALERTS_AND_GUIDANCE)

            // Simulate vehicle progress along the route for demo/debug builds.
            if (BuildConfig.DEBUG) {
              mNavigator
                .getSimulator()
                .simulateLocationsAlongExistingRoute(SimulationOptions().speedMultiplier(5))
            }

            // Start turn-by-turn guidance along the current route.
            mNavigator.startGuidance()
          }
          Navigator.RouteStatus.NO_ROUTE_FOUND -> {
            displayMessage("Error starting navigation: No route found.")
          }
          Navigator.RouteStatus.NETWORK_ERROR -> {
            displayMessage("Error starting navigation: Network error.")
          }
          Navigator.RouteStatus.ROUTE_CANCELED -> {
            displayMessage("Error starting navigation: Route canceled.")
          }
          else -> {
            displayMessage("Error starting navigation: ${code.name}")
          }
        }
      }
    }
  )
}

Swift

private func startNavigation() {
  let destinations = [
    GMSNavigationWaypoint(
      placeID: "ChIJnUYTpNASkFQR_gSty5kyoUk", title: "PCC Natural Market"),
    GMSNavigationWaypoint(
      placeID: "ChIJJ326ROcSkFQRBfUzOL2DSbo", title: "Marina Park"),
  ]

  mapView.navigator?.setDestinations(destinations, callback: { routeStatus in
    guard routeStatus == .OK else {
      // Error starting navigation.
      return
    }
    mapView.locationSimulator?.simulateLocationsAlongExistingRoute()
    mapView.navigator?.isGuidanceActive = true
    mapView.navigator?.sendsBackgroundNotifications = true
    mapView.cameraMode = .following
  })
}

Objective-C

- (void)startNavigation {
  NSArray<GMSNavigationWaypoint *> *destinations =
  @[[[GMSNavigationWaypoint alloc] initWithPlaceID:@"ChIJnUYTpNASkFQR_gSty5kyoUk"
                                             title:@"PCC Natural Market"],
    [[GMSNavigationWaypoint alloc] initWithPlaceID:@"ChIJJ326ROcSkFQRBfUzOL2DSbo"
                                             title:@"Marina Park"]];

  [_mapView.navigator setDestinations:destinations
                             callback:^(GMSRouteStatus routeStatus) {
                               if (routeStatus != GMSRouteStatusOK) {
                                 // Error starting navigation.
                                 return;
                               }
                               [_mapView.locationSimulator simulateLocationsAlongExistingRoute];
                               _mapView.navigator.guidanceActive = YES;
                               _mapView.navigator.sendsBackgroundNotifications = YES;
                               _mapView.cameraMode = GMSNavigationCameraModeFollowing;
                             }];
}

Passaggio 6: Ascolta gli aggiornamenti sui percorsi nell'app per consumatori

• Per Android, puoi ascoltare gli aggiornamenti dei dati di un viaggio ottenendo un oggetto TripModel da TripModelManager e registrando un listener TripModelCallback.

• Per iOS, puoi ascoltare gli aggiornamenti dei dati di una corsa ottenendo un oggetto GMTCTripModel da GMTCTripService e registrando un abbonato GMTCTripModelSubscriber.

Un listener TripModelCallback e un iscritto GMTCTripModelSubscriber consentono alla tua app di ricevere aggiornamenti periodici sullo avanzamento del percorso a ogni aggiornamento in base all'intervallo di aggiornamento automatico. Solo i valori che cambiano possono attivare il callback. In caso contrario, il callback rimane silenzioso.

I metodi TripModelCallback.onTripUpdated() e tripModel(_:didUpdate:updatedPropertyFields:) vengono sempre chiamati, indipendentemente da eventuali modifiche ai dati.

Esempio 1

Il seguente esempio di codice mostra come ottenere un valore TripModel da TripModelManager/GMTCTripService e impostare un listener.

Java

// Start journey sharing after a trip has been created via Fleet Engine.
TripModelManager tripModelManager = consumerApi.getTripModelManager();

// Get a TripModel object.
TripModel tripModel = tripModelManager.getTripModel(tripName);

// Register a listener on the trip.
TripModelCallback tripCallback = new TripModelCallback() {
  ...
};
tripModel.registerTripCallback(tripCallback);

// Set the refresh interval.
TripModelOptions tripModelOptions = TripModelOptions.builder()
    .setRefreshInterval(5000) // interval in milliseconds, so 5 seconds
    .build();
tripModel.setTripModelOptions(tripModelOptions);

// The trip stops auto-refreshing when all listeners are unregistered.
tripModel.unregisterTripCallback(tripCallback);

Kotlin

// Start journey sharing after a trip has been created via Fleet Engine.
val tripModelManager = consumerApi.getTripModelManager()

// Get a TripModel object.
val tripModel = tripModelManager.getTripModel(tripName)

// Register a listener on the trip.
val tripCallback = TripModelCallback() {
  ...
}

tripModel.registerTripCallback(tripCallback)

// Set the refresh interval.
val tripModelOptions =
  TripModelOptions.builder()
    .setRefreshInterval(5000) // interval in milliseconds, so 5 seconds
    .build()

tripModel.setTripModelOptions(tripModelOptions)

// The trip stops auto-refreshing when all listeners are unregistered.
tripModel.unregisterTripCallback(tripCallback)

Swift

let tripService = GMTCServices.shared().tripService

// Create a tripModel instance for listening for updates from the trip
// specified by the trip name.
let tripModel = tripService.tripModel(forTripName: tripName)

// Register for the trip update events.
tripModel.register(self)

// Set the refresh interval (in seconds).
tripModel.options.autoRefreshTimeInterval = 5

// Unregister for the trip update events.
tripModel.unregisterSubscriber(self)

Objective-C

GMTCTripService *tripService = [GMTCServices sharedServices].tripService;

// Create a tripModel instance for listening for updates from the trip
// specified by the trip name.
GMTCTripModel *tripModel = [tripService tripModelForTripName:tripName];

// Register for the trip update events.
[tripModel registerSubscriber:self];

// Set the refresh interval (in seconds).
tripModel.options.autoRefreshTimeInterval = 5;

// Unregister for the trip update events.
[tripModel unregisterSubscriber:self];

Esempio 2

Il seguente esempio di codice mostra come configurare un ascoltatore TripModelCallback e un sottoscrittore GMTCTripModelSubscriber.

Java

// Implements a callback for the trip model so your app can listen for trip
// updates from Fleet Engine.
TripModelCallback subscriber =
  new TripModelCallback() {

    @Override
    public void onTripStatusUpdated(TripInfo tripInfo, @TripStatus int status) {
      // ...
    }

    @Override
    public void onTripActiveRouteUpdated(TripInfo tripInfo, List<LatLng> route) {
      // ...
    }

    @Override
    public void onTripVehicleLocationUpdated(
        TripInfo tripInfo, @Nullable VehicleLocation vehicleLocation) {
      // ...
    }

    @Override
    public void onTripPickupLocationUpdated(
        TripInfo tripInfo, @Nullable TerminalLocation pickup) {
      // ...
    }

    @Override
    public void onTripPickupTimeUpdated(TripInfo tripInfo, @Nullable Long timestampMillis) {
      // ...
    }

    @Override
    public void onTripDropoffLocationUpdated(
        TripInfo tripInfo, @Nullable TerminalLocation dropoff) {
      // ...
    }

    @Override
    public void onTripDropoffTimeUpdated(TripInfo tripInfo, @Nullable Long timestampMillis) {
      // ...
    }

    @Override
    public void onTripETAToNextWaypointUpdated(
        TripInfo tripInfo, @Nullable Long timestampMillis) {
      // ...
    }

    @Override
    public void onTripActiveRouteRemainingDistanceUpdated(
        TripInfo tripInfo, @Nullable Integer distanceMeters) {
      // ...
    }

    @Override
    public void onTripUpdateError(TripInfo tripInfo, TripUpdateError error) {
      // ...
    }

    @Override
    public void onTripUpdated(TripInfo tripInfo) {
      // ...
    }

    @Override
    public void onTripRemainingWaypointsUpdated(
        TripInfo tripInfo, List<TripWaypoint> waypointList) {
      // ...
    }

    @Override
    public void onTripIntermediateDestinationsUpdated(
        TripInfo tripInfo, List<TerminalLocation> intermediateDestinations) {
      // ...
    }

    @Override
    public void onTripRemainingRouteDistanceUpdated(
        TripInfo tripInfo, @Nullable Integer distanceMeters) {
      // ...
    }

    @Override
    public void onTripRemainingRouteUpdated(TripInfo tripInfo, List<LatLng> route) {
      // ...
    }
  };

Kotlin

// Implements a callback for the trip model so your app can listen for trip
// updates from Fleet Engine.
val subscriber =
  object : TripModelCallback() {
    override fun onTripStatusUpdated(tripInfo: TripInfo, status: @TripStatus Int) {
      // ...
    }

    override fun onTripActiveRouteUpdated(tripInfo: TripInfo, route: List<LatLng>) {
      // ...
    }

    override fun onTripVehicleLocationUpdated(
      tripInfo: TripInfo,
      vehicleLocation: VehicleLocation?
    ) {
      // ...
    }

    override fun onTripPickupLocationUpdated(tripInfo: TripInfo, pickup: TerminalLocation?) {
      // ...
    }

    override fun onTripPickupTimeUpdated(tripInfo: TripInfo, timestampMillis: Long?) {
      // ...
    }

    override fun onTripDropoffLocationUpdated(tripInfo: TripInfo, dropoff: TerminalLocation?) {
      // ...
    }

    override fun onTripDropoffTimeUpdated(tripInfo: TripInfo, timestampMillis: Long?) {
      // ...
    }

    override fun onTripETAToNextWaypointUpdated(tripInfo: TripInfo, timestampMillis: Long?) {
      // ...
    }

    override fun onTripActiveRouteRemainingDistanceUpdated(
      tripInfo: TripInfo,
      distanceMeters: Int?
    ) {
      // ...
    }

    override fun onTripUpdateError(tripInfo: TripInfo, error: TripUpdateError) {
      // ...
    }

    override fun onTripUpdated(tripInfo: TripInfo) {
      // ...
    }

    override fun onTripRemainingWaypointsUpdated(
      tripInfo: TripInfo,
      waypointList: List<TripWaypoint>
    ) {
      // ...
    }

    override fun onTripIntermediateDestinationsUpdated(
      tripInfo: TripInfo,
      intermediateDestinations: List<TerminalLocation>
    ) {
      // ...
    }

    override fun onTripRemainingRouteDistanceUpdated(tripInfo: TripInfo, distanceMeters: Int?) {
      // ...
    }

    override fun onTripRemainingRouteUpdated(tripInfo: TripInfo, route: List<LatLng>) {
      // ...
    }
  }

Swift

class TripModelSubscriber: NSObject, GMTCTripModelSubscriber {

  func tripModel(_: GMTCTripModel, didUpdate trip: GMTSTrip?, updatedPropertyFields: GMTSTripPropertyFields) {
    // Update the UI with the new `trip` data.
    updateUI(with: trip)
    ...
  }

  func tripModel(_: GMTCTripModel, didUpdate tripStatus: GMTSTripStatus) {
    // Handle trip status did change.
  }

  func tripModel(_: GMTCTripModel, didUpdateActiveRoute activeRoute: [GMTSLatLng]?) {
    // Handle trip active route did update.
  }

  func tripModel(_: GMTCTripModel, didUpdate vehicleLocation: GMTSVehicleLocation?) {
    // Handle vehicle location did update.
  }

  func tripModel(_: GMTCTripModel, didUpdatePickupLocation pickupLocation: GMTSTerminalLocation?) {
    // Handle pickup location did update.
  }

  func tripModel(_: GMTCTripModel, didUpdateDropoffLocation dropoffLocation: GMTSTerminalLocation?) {
    // Handle drop off location did update.
  }

  func tripModel(_: GMTCTripModel, didUpdatePickupETA pickupETA: TimeInterval) {
    // Handle the pickup ETA did update.
  }

  func tripModel(_: GMTCTripModel, didUpdateDropoffETA dropoffETA: TimeInterval) {
    // Handle the drop off ETA did update.
  }

  func tripModel(_: GMTCTripModel, didUpdateRemaining remainingWaypoints: [GMTSTripWaypoint]?) {
    // Handle updates to the pickup, dropoff or intermediate destinations of the trip.
  }

  func tripModel(_: GMTCTripModel, didFailUpdateTripWithError error: Error?) {
    // Handle the error.
  }

  func tripModel(_: GMTCTripModel, didUpdateIntermediateDestinations intermediateDestinations: [GMTSTerminalLocation]?) {
    // Handle the intermediate destinations being updated.
  }

  ...
}

Objective-C

@interface TripModelSubscriber : NSObject <GMTCTripModelSubscriber>
@end

@implementation TripModelSubscriber

- (void)tripModel:(GMTCTripModel *)tripModel
            didUpdateTrip:(nullable GMTSTrip *)trip
    updatedPropertyFields:(GMTSTripPropertyFields)updatedPropertyFields {
  // Update the UI with the new `trip` data.
  [self updateUIWithTrip:trip];
  ...
}

- (void)tripModel:(GMTCTripModel *)tripModel didUpdateTripStatus:(enum GMTSTripStatus)tripStatus {
  // Handle trip status did change.
}

- (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateActiveRoute:(nullable NSArray<GMTSLatLng *> *)activeRoute {
  // Handle trip route did update.
}

- (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateVehicleLocation:(nullable GMTSVehicleLocation *)vehicleLocation {
  // Handle vehicle location did update.
}

- (void)tripModel:(GMTCTripModel *)tripModel
    didUpdatePickupLocation:(nullable GMTSTerminalLocation *)pickupLocation {
  // Handle pickup location did update.
}

- (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateDropoffLocation:(nullable GMTSTerminalLocation *)dropoffLocation {
  // Handle drop off location did update.
}

- (void)tripModel:(GMTCTripModel *)tripModel didUpdatePickupETA:(NSTimeInterval)pickupETA {
  // Handle the pickup ETA did update.
}

- (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateRemainingWaypoints:(nullable NSArray<GMTSTripWaypoint *> *)remainingWaypoints {
  // Handle updates to the pickup, dropoff or intermediate destinations of the trip.
}

- (void)tripModel:(GMTCTripModel *)tripModel didUpdateDropoffETA:(NSTimeInterval)dropoffETA {
  // Handle the drop off ETA did update.
}

- (void)tripModel:(GMTCTripModel *)tripModel didFailUpdateTripWithError:(nullable NSError *)error {
  // Handle the error.
}

- (void)tripModel:(GMTCTripModel *)tripModel
    didUpdateIntermediateDestinations:
        (nullable NSArray<GMTSTerminalLocation *> *)intermediateDestinations {
  // Handle the intermediate destinations being updated.
}
…
@end

Puoi accedere alle informazioni sulla corsa in qualsiasi momento come segue:

• Chiama l'SDK consumer per Android TripModel.getTripInfo(). La chiamata di questo metodo non forza l'aggiornamento dei dati, anche se i dati continuano a essere aggiornati alla frequenza di aggiornamento.

• Scarica l'SDK consumer per la proprietà iOS GMTCTripModel.currentTrip.

Passaggio 7: Aggiorna la corsa con l'ID veicolo

Devi configurare la corsa con un ID veicolo in modo che Fleet Engine possa monitorare il veicolo lungo il suo percorso.

• Puoi aggiornare la corsa con l'ID veicolo chiamando l'endpoint UpdateTrip con un UpdateTripRequest. Utilizza il campo update_mask per specificare che stai aggiornando l'ID veicolo.

Note

• Se non specifichi una destinazione quando crei il viaggio, puoi sempre farlo qui.

• Se devi cambiare il veicolo di una corsa in corso, devi impostare di nuovo lo stato della corsa e poi aggiornare la corsa (come hai fatto sopra) con il nuovo ID veicolo.

Esempio

Il seguente esempio di codice mostra come aggiornare la corsa con un ID veicolo.

static final String PROJECT_ID = "my-rideshare-co-gcp-project";
static final String TRIP_ID = "trip-8241890";

String tripName = "providers/" + PROJECT_ID + "/trips/" + TRIP_ID;

TripServiceBlockingStub tripService = TripService.newBlockingStub(channel);

// The trip settings to update.
Trip trip = Trip.newBuilder()
    .setVehicleId("8241890")
    .build();

// The trip update request.
UpdateTripRequest updateTripRequest =
    UpdateTripRequest.newBuilder()      // No need for the header.
        .setName(tripName)
        .setTrip(trip)
        .setUpdateMask(FieldMask.newBuilder().addPaths("vehicle_id"))
        .build();

// Error handling.
// If the Fleet Engine has both a trip and vehicle with IDs, and if the
// credentials validate, then the service updates the trip.
try {
  Trip updatedTrip = tripService.updateTrip(updateTripRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
    case NOT_FOUND:                    // Neither the trip nor vehicle exist.
      break;
    case PERMISSION_DENIED:
      break;
  }
  return;
}

Passaggio 8: Visualizzare il percorso nell'app del consumatore

Usa l'oggetto ConsumerController per accedere alle API degli elementi dell'interfaccia utente Rides and Deliveries.

Per ulteriori informazioni, consulta la sezione Utilizzo delle API degli elementi dell'interfaccia utente.

Esempio

Il seguente esempio di codice mostra come iniziare il percorso condividendo l'interfaccia utente.

Java

JourneySharingSession session = JourneySharingSession.createInstance(tripModel);
consumerController.showSession(session);

Kotlin

val session = JourneySharingSession.createInstance(tripModel)
consumerController.showSession(session)

Swift

let journeySharingSession = GMTCJourneySharingSession(tripModel: tripModel)
mapView.show(journeySharingSession)

Objective-C

GMTCJourneySharingSession *journeySharingSession =
    [[GMTCJourneySharingSession alloc] initWithTripModel:tripModel];
[self.mapView showMapViewSession:journeySharingSession];

Passaggio 9. Gestisci lo stato della corsa in Fleet Engine

Puoi specificare lo stato di una corsa utilizzando uno dei valori di enumerazione di TripStatus. Quando lo stato di una corsa cambia (ad esempio, da ENROUTE_TO_PICKUP a ARRIVED_AT_PICKUP), devi aggiornarlo tramite Fleet Engine. Lo stato del viaggio inizia sempre con il valore NEW e termina con un valore di COMPLETE o CANCELED. Per maggiori informazioni, consulta trip_status.

Esempio

Il seguente esempio di codice mostra come aggiornare lo stato della corsa in Fleet Engine.

static final String PROJECT_ID = "my-rideshare-co-gcp-project";
static final String TRIP_ID = "trip-8241890";

String tripName = "providers/" + PROJECT_ID + "/trips/" + TRIP_ID;

TripServiceBlockingStub tripService = TripService.newBlockingStub(channel);

// Trip settings to be updated.
Trip trip = Trip.newBuilder()
    .setTripStatus(TripStatus.ARRIVED_AT_PICKUP)
    .build();

// Trip update request
UpdateTripRequest updateTripRequest = UpdateTripRequest.newBuilder()
    .setName(tripName)
    .setTrip(trip)
    .setUpdateMask(FieldMask.newBuilder().addPaths("trip_status"))
    .build();

// Error handling.
try {
  Trip updatedTrip = tripService.updateTrip(updateTripRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
    case NOT_FOUND:            // The trip doesn't exist.
      break;
    case FAILED_PRECONDITION:  // The given trip status is invalid.
      break;
    case PERMISSION_DENIED:
      break;
  }
  return;
}