Crea viaggi di pooling condivisi

Questo documento descrive come creare un viaggio di pooling condiviso, impostare i campi corretti e assegnarlo a un veicolo per l'esecuzione. Si presuppone che tu abbia configurato Fleet Engine, creato veicoli, disponga di un'app per autisti funzionante e, facoltativamente, di un'app per i consumatori. Dovresti anche conoscere i vari scenari di viaggio disponibili per i viaggi on demand. Per farlo, consulta le seguenti guide correlate:

Nozioni di base sulla creazione di viaggi

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

  • Metodo CreateTrip(): gRPC o REST
  • Messaggio CreateTripRequest: gRPC solo

Campi del viaggio

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

Campi del viaggio
Nome Obbligatorio? Descrizione
parent Sì Una stringa che include l'ID progetto. Questo ID deve essere lo stesso utilizzato in tutta l'integrazione di Fleet Engine, con gli stessi ruoli dell'account di servizio.
trip_id Sì Una stringa che crei che identifica in modo univoco questo viaggio. Gli ID viaggio hanno alcune 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: imposta su EXCLUSIVE.
  • Consecutivi: imposta su EXCLUSIVE.
  • Pooling condiviso: imposta su SHARED.
pickup_point Sì Il punto di origine del viaggio.
Destinazioni intermedie Sì

Solo viaggi con più destinazioni: l'elenco delle destinazioni intermedie che l'autista visita tra il punto di prelievo e quello di riconsegna. 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 di pooling condiviso: questo campo supporta l'interleaving dei waypoint di più viaggi. Contiene tutti i waypoint rimanenti per il veicolo assegnato, nonché i waypoint di prelievo 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. Per motivi di privacy, il servizio non restituisce queste informazioni nelle chiamate GetTrip

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 di pooling condiviso

Il seguente esempio di integrazione backend mostra come creare un viaggio e assegnarlo a un veicolo come viaggio di pooling 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 di pooling condiviso

Per consentire a Fleet Engine di calcolare gli ETA dei viaggi e monitorarli, è necessario assegnare un viaggio creato in Fleet Engine a un veicolo. Puoi farlo durante la creazione del viaggio o in un secondo momento quando lo aggiorni.

Per i viaggi di pooling condiviso, devi specificare un ordine per i waypoint non visitati nella raccolta di waypoint del veicolo del viaggio (Trip.vehicle_waypoints). Fleet Engine utilizza questo elenco per aggiornare automaticamente i waypoint del viaggio per tutti i viaggi nel pool condiviso.

Ad esempio, considera due viaggi di pooling condiviso, il viaggio A e il viaggio B:

  • Il viaggio A è in corso verso la sua posizione di riconsegna.
  • Il viaggio B viene aggiunto allo stesso veicolo.

In una UpdateTripRequest per il viaggio B, imposta vehicleId e Trip.vehicle_waypoints sull'ordine ottimale dei waypoint: prelievo B → riconsegna A → riconsegna B.

  • La chiamata a getVehicle() restituisce remainingWaypoints che contengono:
    B prelievo → A riconsegna → B riconsegna.
  • getTrip() o il onTripRemainingWaypointsUpdated callback per il viaggio A restituisce remainingWaypoints che contengono:
    B prelievo → A riconsegna.
  • getTrip() o il onTripRemainingWaypointsUpdated callback per il viaggio B restituisce remainingWaypoints che contengono:
    B prelievo → A riconsegna → B riconsegna.

Esempio

Il seguente esempio di integrazione backend mostra come aggiornare un viaggio con l'ID veicolo e i waypoint per due viaggi di pooling 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