Questa pagina è stata tradotta dall'API Cloud Translation.

Crea viaggi di pooling condivisi

Questo documento descrive come creare un viaggio di pooling condiviso, impostare il percorso corretto e assegnarlo a un veicolo da completare. Si presume che tu abbia configurato il parco risorse Engine, hai creato veicoli, disponi di un'app per conducente funzionante e un'app consumer, facoltativamente. Dovresti anche conoscere i vari percorsi disponibili per le corse on demand. Consulta le seguenti guide correlate per che:

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

Nozioni di base sulla creazione di viaggi

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

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

di Gemini Advanced.

Campi viaggio

Utilizza i campi seguenti per creare una corsa in Fleet Engine. Puoi utilizzare diversi per i diversi tipi di viaggio: singola o più destinazione, di sequenze consecutive o di pooling condivisi. Tu può fornire i campi facoltativi quando crei il viaggio oppure puoi impostarli in un secondo momento, quando aggiorni la corsa.

Campi corsa
Nome	Obbligatorio?	Descrizione
padre	Sì	Una stringa che include l'ID progetto. Questo ID deve essere lo stesso utilizzato nell'intera integrazione di Fleet Engine, con lo stesso account di servizio ruoli.
trip_id	Sì	Una stringa creata da te che identifica in modo univoco questa corsa. Gli ID viaggio sono alcune limitazioni, come indicato nel riferimento.
trip_type	Sì	Imposta TripType sui seguenti valori per il tipo di viaggio che stai creando: Destinazione singola: imposta su `SHARED` o `EXCLUSIVE`. Più destinazioni: imposta su `EXCLUSIVE`. Dietro a croce: imposta su `EXCLUSIVE`. Pooling condiviso: impostato su `SHARED`.
pickup_point	Sì	Il punto di partenza della corsa.
Destinazioni intermedie	Sì	Solo viaggi con più destinazioni: l'elenco delle destinazioni intermedie visitate dal conducente. ritiro e consegna. Come per `dropoff_point`, questo campo può anche essere impostata in un secondo momento chiamando `UpdateTrip`, ma un indirizzo multi-destinazione viaggio per definizione contiene destinazioni intermedie.
vehicle_waypoints	Sì	Solo corse in pool condivise: questo campo supporta l'interfoliazione delle tappe di più corse. Contiene tutte le tappe rimanenti per il veicolo assegnato, nonché come tappe di partenza e arrivo della corsa. Puoi impostare questo campo chiamando `CreateTrip` o `UpdateTrip`. Puoi anche aggiorna le tappe dei veicoli tramite il campo `waypoints` con un chiamata a `UpdateVehicle`. Il servizio non restituisce queste informazioni per le chiamate `GetTrip` per motivi di privacy.
number_of_passengers	No	Il numero di passeggeri della corsa.
dropoff_point	No	La destinazione del viaggio.
vehicle_id	No	L'ID del veicolo assegnato alla corsa.

Esempio: creare un viaggio di pooling condiviso

Il seguente esempio di integrazione del backend mostra come creare un viaggio assegnarlo a un veicolo come percorso 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;
}

Aggiorna le corse di pooling condivise

Qualsiasi corsa creata in Fleet Engine deve essere assegnata a un veicolo per Fleet Engine per calcolare l'orario di arrivo stimato delle corse e monitorarlo. Puoi eseguire questa operazione durante la creazione di un percorso o in un secondo momento quando lo aggiorni.

Per le corse in pooling condivise, devi specificare un ordine per le tappe non visitate nella raccolta di tappe del percorso dei veicoli (Trip.vehicle_waypoints). Parco risorse Il motore utilizza questo elenco per aggiornare automaticamente le tappe di tutti i viaggi nel pool condiviso.

Ad esempio, considera due corse in piscina condivisa, Trip A e Percorso B:

La corsa A è in viaggio verso il punto di partenza.
La corsa B viene quindi aggiunta allo stesso veicolo.

In un UpdateTripRequest per il Trip B, imposti vehicleId e anche Trip.vehicle_waypoints sul valore ottimale ordine tappa: B _Ritiro → Un _abbandono → B _Abbandono.

La chiamata a getVehicle() restituisce remainingWaypoints che contengono:
B _Ritiro → Un _abbandono → B _Abbandono.
getTrip() o Callback onTripRemainingWaypointsUpdated per Il Trip A restituisce remainingWaypoints che contengono:
B _Ritiro → Un _abbandono.
getTrip() o Callback onTripRemainingWaypointsUpdated per Trip B restituisce remainingWaypoints che contengono:
B _Ritiro → Un _abbandono → B _Abbandono.

Esempio

Il seguente esempio di integrazione del backend mostra come aggiornare una corsa con l'ID veicolo e le tappe 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