Questa pagina è stata tradotta dall'API Cloud Translation.

Crea viaggi di pooling condivisi

Questo documento descrive come creare un viaggio in pool condiviso, impostare i campi corretti e assegnarlo a un veicolo da soddisfare. Si presume che tu abbia configurato Fleet Engine, creato veicoli, disponga di un'app per i conducenti funzionante e, facoltativamente, di un'app per i consumatori. Inoltre, devi conoscere i vari scenari di viaggio disponibili per i viaggi on demand. Consulta le seguenti guide correlate per approfondire:

Configurare Fleet Engine
Creare un veicolo
Scenari di viaggio nella panoramica Viaggi on demand

Nozioni di base sulla creazione di viaggi

Questa sezione descrive i dettagli della richiesta necessari per creare un viaggio in Fleet Engine. Emetti una richiesta di creazione utilizzando gRPC e REST.

Metodo CreateTrip(): gRPC o REST
CreateTripRequest message: solo gRPC

Campi relativi alla corsa

Utilizza i seguenti campi per creare un viaggio in Fleet Engine. Puoi utilizzare diversi campi per i diversi tipi di corse: con una o più destinazioni, consecutive o con pooling condiviso. Puoi fornire i campi facoltativi quando crei il viaggio oppure impostarli in un secondo momento quando aggiorni il viaggio.

Campi relativi ai viaggi
Nome	Obbligatorio?	Descrizione
parent	Sì	Una stringa che include l'ID progetto. Questo ID deve essere lo stesso ID utilizzato nell'intera integrazione di Fleet Engine, con gli stessi ruoli dell'account di servizio.
trip_id	Sì	Una stringa creata da te che identifica in modo univoco questo viaggio. Gli ID viaggio hanno determinate limitazioni, come indicato nel riferimento.
trip_type	Sì	Imposta TripType sui seguenti valori per il tipo di viaggio che stai creando: Singola destinazione: imposta su `SHARED` o `EXCLUSIVE`. Più destinazioni: impostato su `EXCLUSIVE`. Back-to-back: impostato su `EXCLUSIVE`. Raggruppamento condiviso: impostato su `SHARED`.
pickup_point	Sì	Il punto di partenza del viaggio.
Destinazioni intermedie	Sì	Solo per i viaggi con più destinazioni: l'elenco delle destinazioni intermedie che il conducente visita tra il ritiro e la consegna. Come per `dropoff_point`, questo campo può essere impostato anche in un secondo momento chiamando `UpdateTrip`, ma un viaggio con più destinazioni per definizione contiene destinazioni intermedie.
vehicle_waypoints	Sì	Solo viaggi con car pooling: questo campo supporta l'interlacciamento dei waypoint di più viaggi. Contiene tutti i waypoint rimanenti per il veicolo assegnato, nonché i waypoint di ritiro e riconsegna per questo viaggio. Puoi impostare questo campo chiamando `CreateTrip` o `UpdateTrip`. Puoi anche aggiornare i waypoint del veicolo tramite il campo `waypoints` con una chiamata a `UpdateVehicle`. Il servizio non restituisce queste informazioni sulle chiamate `GetTrip` per motivi di privacy.
number_of_passengers	No	Il numero di passeggeri del viaggio.
dropoff_point	No	La destinazione del viaggio.
vehicle_id	No	L'ID del veicolo assegnato al viaggio.

Esempio: creare un viaggio in pool condiviso

Il seguente esempio di integrazione di backend mostra come creare un viaggio e assegnatelo a un veicolo come viaggio in pool condiviso.

// Vehicle with VEHICLE_ID ID is already created and it is assigned Trip A.

static final String PROJECT_ID = "my-rideshare-co-gcp-project";
static final String TRIP_ID = "shared-trip-A";
static final String VEHICLE_ID = "your-vehicle-id";
static final String TRIP_A_ID = "trip-a-id";
static final String TRIP_B_ID = "trip-b-id";

TripServiceBlockingStub tripService = TripService.newBlockingStub(channel);

String parent = "providers/" + PROJECT_ID;

LatLng tripBPickup =
    LatLng.newBuilder().setLatitude(-12.12314).setLongitude(88.142123).build();
LatLng tripBDropoff =
    LatLng.newBuilder().setLatitude(-14.12314).setLongitude(90.142123).build();

TerminalLocation tripBPickupTerminalLocation =
    TerminalLocation.newBuilder().setPoint(tripBPickup).build();
TerminalLocation tripBDropoffTerminalLocation =
    TerminalLocation.newBuilder().setPoint(tripBDropoff).build();

// TripA already exists and it's assigned to a vehicle with VEHICLE_ID ID.
Trip tripB = Trip.newBuilder()
    .setTripType(TripType.SHARED)
    .setVehicleId(VEHICLE_ID)
    .setPickupPoint(tripBPickupTerminalLocation)
    .setDropoffPoint(tripBDropoffTerminalLocation)
    .addAllVehicleWaypoints(
        // This is where you define the arrival order for unvisited waypoints.
        // If you don't specify an order, then the Fleet Engine adds Trip B's
        // waypoints to the end of Trip A's.
        ImmutableList.of(
            // Trip B's pickup point.
            TripWaypoint.newBuilder()
                .setLocation(tripBPickupTerminalLocation)
                .setTripId(TRIP_B_ID)
                .setWaypointType(WaypointType.PICKUP_WAYPOINT_TYPE)
                .build(),
            // Trip A's drop-off point.
            TripWaypoint.newBuilder()
                .setLocation(tripA.getDropoffPoint())
                .setTripId(TRIP_A_ID)
                .setWaypointType(WaypointType.DROP_OFF_WAYPOINT_TYPE)
                .build(),
            // Trip B's drop-off point.
            TripWaypoint.newBuilder()
                .setLocation(tripBDropoffTerminalLocation)
                .setTripId(TRIP_B_ID)
                .setWaypointType(WaypointType.DROP_OFF_WAYPOINT_TYPE)
                .build()))
    .build();

// Create Trip request
CreateTripRequest createTripRequest = CreateTripRequest.newBuilder()
    .setParent(parent)
    .setTripId(TRIP_B_ID)
    .setTrip(tripB)
    .build();

try {
  // createdTrip.remainingWaypoints will contain shared-pool waypoints.
  // [tripB.pickup, tripA.dropoff, tripB.dropoff]
  Trip createdTrip = tripService.createTrip(createTripRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
    case ALREADY_EXISTS:
      break;
    case PERMISSION_DENIED:
      break;
  }
  return;
}

Aggiornare i viaggi condivisi in pool

Per poter calcolare le stime di arrivo e monitorare i viaggi, ogni viaggio creato in Fleet Engine deve essere assegnato a un veicolo. Puoi farlo durante la creazione della corsa o in un secondo momento quando aggiorni la corsa.

Per le corse con car pooling, devi specificare un ordine per i waypoint non visitati nella raccolta di waypoint del veicolo della corsa (Trip.vehicle_waypoints). Fleet Engine utilizza questo elenco per aggiornare automaticamente i waypoint delle corse per tutte le corse nel pool condiviso.

Ad esempio, considera due corse con pool condiviso, Viaggio A e Viaggio B:

La corsa A è in viaggio verso la stazione di ricarica.
La corsa B viene poi aggiunta allo stesso veicolo.

In un UpdateTripRequest per il viaggio B, imposta vehicleId e anche Trip.vehicle_waypoints sull'ordine ottimale dei punti di passaggio: B _Ritiro → A _Risalita → B _Risalita.

La chiamata a getVehicle() restituisce remainingWaypoints che contiene:
B _Ritiro → A _Consegna → B _Consegna.
getTrip() o il callback onTripRemainingWaypointsUpdated per Viaggio A restituisce remainingWaypoints che contengono:
B _Ritiro → A _Ritrovamento.
getTrip() o il callback onTripRemainingWaypointsUpdated per Viaggio B restituisce remainingWaypoints contenente:
B _Ritiro → A _Rilascia → B _Rilascia.

Esempio

Il seguente esempio di integrazione di backend mostra come aggiornare una corsa con l'ID veicolo e i waypoint per due corse in pool condiviso.

static final String PROJECT_ID = "my-rideshare-co-gcp-project";
static final String TRIP_A_ID = "share-trip-A";
static final String TRIP_B_ID = "share-trip-B";
static final String VEHICLE_ID = "Vehicle";

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

// Get Trip A and Trip B objects from either the Fleet Engine or storage.
Trip tripA = …;
Trip tripB = …;

TripServiceBlockingStub tripService = TripService.newBlockingStub(channel);

// The trip settings to update.
Trip trip = Trip.newBuilder()
    .setVehicleId(VEHICLE_ID)
    .addAllVehicleWaypoints(
        // This is where you define the arrival order for unvisited waypoints.
        // If you don't specify an order, then the Fleet Engine adds Trip B's
        // waypoints to the end of Trip A's.
        ImmutableList.of(
            // Trip B's pickup point.
            TripWaypoint.newBuilder()
                .setLocation(tripB.getPickupPoint())
                .setTripId(TRIP_B_ID)
                .setWaypointType(WaypointType.PICKUP_WAYPOINT_TYPE)
                .build(),
            // Trip A's drop-off point.
            TripWaypoint.newBuilder()
                .setLocation(tripA.getDropoffPoint())
                .setTripId(TRIP_A_ID)
                .setWaypointType(WaypointType.DROP_OFF_WAYPOINT_TYPE)
                .build(),
            // Trip B's drop-off point.
            TripWaypoint.newBuilder()
                .setLocation(tripB.getDropoffPoint())
                .setTripId(TRIP_B_ID)
                .setWaypointType(WaypointType.DROP_OFF_WAYPOINT_TYPE)
                .build()))
    .build();

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

// Error handling. If Fleet Engine has both a trip and vehicle with the IDs,
// and if the credentials validate, and if the given vehicle_waypoints list
// is valid, 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:          // Either the trip or vehicle does not exist.
      break;
    case PERMISSION_DENIED:
      break;
    case INVALID_REQUEST:    // vehicle_waypoints is invalid.
      break;
  }
  return;
}

Passaggi successivi

Configurare l'SDK Driver