Comienza a usar Fleet Engine para el seguimiento de envíos

Modela las actividades de tu flota para el primer y el último tramo de las entregas con la API de Fleet Engine Deliveries. Puedes usar esta API con el SDK de Driver para Android. e iOS, o directamente a través de llamadas REST de HTTP o gRPC.

Configuración inicial

Configura la API de Fleet Engine Deliveries en la consola de Google Cloud.

• Para obtener información sobre los pasos a seguir en la consola y cómo crear un token web JSON para autorización, consulta Autenticación y autorización.

• Para obtener detalles sobre el uso de la consola, consulta la Documentación de la consola de Google Cloud.

Verifica la configuración

Después de crear las cuentas de servicio, verifica que se haya completado la configuración y puedes crear un vehículo de reparto. Verificar la configuración de inmediato garantiza que hayas abordado los problemas de autorización comunes que pueden surgir cuando configurar tu proyecto. Existen dos maneras de verificar la configuración:

• Prueba dos partes clave de tu configuración: la firma del token de autorización y la entrega de prueba. la creación del vehículo con la Utilidad de línea de comandos de gcloud. Para consulta el artículo Cómo verificar la configuración .

• Prueba tu configuración con el Secuencias de comandos de muestra de autenticación de flotas.

Bibliotecas cliente

Para una mejor experiencia del desarrollador con gRPC o REST sin procesar, usa el las bibliotecas cliente en varios lenguajes de programación comunes. Para instrucciones sobre cómo obtener bibliotecas cliente para tu aplicación de servidor, consulta Bibliotecas cliente.

En los ejemplos de Java en esta documentación, se supone que estás familiarizado con gRPC.

Estructuras de datos

La API de Fleet Engine Deliveries usa dos estructuras de datos para modelar el retiro y la entrega. de los envíos:

• Indica el vehículo de entrega que se usa para transportar el envío.
• Las tareas de retiro y entrega del envío

También usas tareas para modelar los descansos de los conductores y las paradas programadas. a lo largo del día.

Vehículos de reparto

Los vehículos de entrega transportan los envíos de un depósito a una ubicación de entrega y desde el punto de partida hasta el depósito. En algunos casos, también pueden transportar un envío directamente desde el lugar de retiro hasta el lugar de entrega.

Usa el SDK del controlador para crear un objeto DeliveryVehicle en Fleet Engine actualizaciones de ubicación para hacer un seguimiento de la flotilla.

Tasks

Para las acciones que realiza un vehículo durante el día, asignas tareas según el tipo de acción:

• Para los retiros y las entregas, asigna tareas de envío.
• En los momentos en que los conductores no están disponibles, como los recesos obligatorios, asigna Tareas de falta de disponibilidad.
• Para las tareas no relacionadas con la conducción en buzones o ubicaciones de clientes, asigna Tareas de detención programadas.

Cada tarea que asignes debe tener un ID de tarea único, pero las tareas pueden compartir el mismo el ID de seguimiento. Cuando Fleet Engine calcula la hora de llegada estimada ventanas para cada tarea, utiliza todas las tareas y el orden en que están programados para hacer estimaciones. Para obtener más información sobre los IDs de tareas, consulta Lineamientos de la ID de tarea.

Para crear tareas en Fleet Engine, usa el Administrador de tareas del SDK de Driver.

Tareas de envío

Crear tareas de envío para el retiro y la entrega de un envío incluye la siguiente información:

• Es la ubicación del retiro o la entrega.
• Un número de seguimiento o ID.
• Un tiempo de permanencia para tener en cuenta el tiempo adicional para completar la tarea, observa para estacionar o caminar hasta el lugar de transferencia.
• Un ID de tarea único. Consulta los Lineamientos sobre ID de tareas.

Para obtener más información, consulta los siguientes temas:

Android

• Cómo crear una tarea de retiro del envío
• Cómo crear una tarea de entrega de envíos

iOS

• GMTD DeliveryTaskManager.
• GMTSTaskType

Tareas de falta de disponibilidad

Las tareas de indisponibilidad cubren períodos en los que un vehículo no está disponible para retiros o entregas, como pausas para cargar combustible al vehículo o al conductor descansos.

Crea una tarea de falta de disponibilidad con la siguiente información:

• Es la duración de la pausa.
• La ubicación de la pausa (opcional). No tienes que proporcionar una ubicación específica, pero al hacerlo, se proporcionan períodos de hora de llegada más precisos a lo largo del día.

Para obtener más información, consulta los siguientes temas:

Android

• Falta de disponibilidad programada

iOS

• GMTD DeliveryTaskManager.
• GMTSTaskType

Tareas de detención programadas

Crea tareas de paradas programadas para modelar las paradas que necesita un vehículo de reparto que hacer. Por ejemplo, crea una tarea de detención programada para una tarea de detención diaria parada de recolección en una ubicación específica, independientemente de otras entregas o puntos de partida en el mismo lugar. También puedes crear tareas de detención programadas para las recolecciones, desde cajones de entrega o hasta trasbordos de vehículos alimentadores y modelos. o paradas en centros de servicio y puntos de servicio.

Para obtener más información, consulta los siguientes temas:

Android

• Paradas programadas

iOS

• GMTD DeliveryTaskManager.
• GMTSTaskType

Lineamientos sobre IDs de tareas

Cuando crees IDs de tareas, sigue estos lineamientos de contenido y formato:

• Crea IDs de tarea únicos
• No expongas información de identificación personal (PII) ni borrar datos de texto.
• Usa cadenas Unicode válidas.
• Usa 64 caracteres como máximo.
• No incluyas ninguno de los siguientes caracteres ASCII: “/”, “":", "\", "?" o "#".
• Normaliza de acuerdo con el formulario C de normalización de Unicode.

Los siguientes son algunos ejemplos de buenos IDs de tarea:

• 566c33d9-2a31-4b6a-9cd4-80ba1a0c643b
• e4708eabcfa39bf2767c9546c9273f747b4626e8cc44e9630d50f6d129013d38
• NTA1YTliYWNkYmViMTI0ZmMzMWFmOWY2NzNkM2Jk

En la siguiente tabla, se muestran ejemplos de IDs de tareas no compatibles:

Más recursos

Para ver los campos específicos contenidos en cada dato consulta la documentación de referencia de la API para DeliveryVehicle (gRPC, REST) y Task (gRPC, REST).

Duración de un vehículo

El objeto DeliveryVehicle representa un vehículo de entrega para el tramo inicial o el último tramo. Se crea un objeto DeliveryVehicle con lo siguiente:

• El ID del proyecto de Google Cloud que contiene la cuenta de servicio para llamar a las APIs de Fleet Engine.
• Un ID de vehículo de propiedad del cliente.

Usa IDs de vehículos únicos para cada vehículo. No vuelvas a usar el ID de un vehículo a menos que no haya tareas activas para el vehículo original.

Fleet Engine borra automáticamente DeliveryVehicle de objetos que no han se actualizó con UpdateDeliveryVehicle después de siete días. Lo recomendado para mantener disponible un vehículo en Fleet Engine es actualizar su ubicación a intervalos regulares. Actualizaciones de la mayoría de los demás campos de DeliveryVehicle la entidad también extenderá su vida, siempre que el nuevo valor del campo sea diferente a partir del existente.

Para ver si un vehículo existe, haz lo siguiente:

1. Realiza una llamada a UpdateDeliveryVehicle.
2. Si recibes un error NOT_FOUND, llama a CreateDeliveryVehicle. para recrear el vehículo. Si la llamada devuelve un vehículo, aún estará disponible para su actualización.

Tipos de vehículos

La entidad VehicleType contiene un campo opcional de VehicleType que incluye un Enumeración Category que puedes especificar como AUTO, TWO_WHEELER, BICYCLE o PEDESTRIAN Si no configuras el campo, el valor predeterminado es AUTO.

En todas las rutas para vehículos, se utiliza el RouteTravelMode correspondiente para el tipo de vehículo.

Atributos del vehículo

La entidad DeliveryVehicle contiene un campo repetido de DeliveryVehicleAttribute La API de ListDeliveryVehicles incluye un filter que puede limitar las entidades DeliveryVehicle devueltas a aquellas con el atributos específicos. DeliveryVehicleAttribute no afecta a Fleet Engine y el comportamiento de enrutamiento.

No incluyas información de identificación personal (PII) ni información sensible en los atributos, ya que este campo puede ser visible para los usuarios.

Ciclo de una tarea

Puedes crear, actualizar y consultar tareas en Fleet Engine con las interfaces gRPC o REST de la API de Deliveries.

Un objeto Task tiene un campo de estado para hacer un seguimiento de su progreso su ciclo de vida. Los valores se mueven de OPEN a CLOSED. Se crean tareas nuevas en estado ABIERTO, lo que indica lo siguiente:

• La tarea aún no se asignó a ningún vehículo de entrega.
• El vehículo de entrega aún no ha pasado la parada vehicular asignada a la tarea.

Lineamientos de las tareas

Solo puedes asignar una tarea a un vehículo cuando está en estado ABIERTO.

Para cancelar una tarea, la quitas de la lista de paradas del vehículo, lo que establece la el estado de la tarea a CLOSED automáticamente.

Cuando el vehículo de la tarea complete la detención vehicular de la tarea, ocurrirá lo siguiente:

1. Actualiza el campo de resultado de la tarea a SUCCEEDED o FAILED.

2. Especifica la marca de tiempo del evento.

   Luego, la biblioteca JavaScript Shipment Tracking indica el resultado de la tarea y el estado de la tarea se configura como CERRADA automáticamente. Para obtener más información, consulta Realiza un seguimiento de tu envío con la biblioteca JavaScript Shipment Tracking.

Al igual que con los vehículos, Fleet Engine borra las tareas que no se actualizaron después de siete días, y si intentas crear una tarea con un ID que ya existe, se mostrará un error.

Nota: Fleet Engine no admite que se borre una tarea de forma explícita. El servicio borra automáticamente las tareas después de siete días sin actualizaciones. Si deseas conservar los datos de las tareas por más de siete días, debes implementar esa capacidad por tu cuenta.

Atributos de la tarea

La entidad Task contiene un campo repetido de TaskAttribute, que puede tener un valor de uno de los 3 tipos: cadena o número y booleano. La API de ListTasks incluye un campo filter que puede limitar los datos que se muestran Task a aquellas con los atributos especificados. Los atributos de la tarea afectar el comportamiento de enrutamiento de Fleet Engine.

No incluyas información de identificación personal (PII) ni otro tipo de información sensible información en los atributos, ya que estos pueden ser visibles para los usuarios.

Administra el ciclo de vida del vehículo y las tareas

Recordatorio: Su sistema interno actúa como la fuente confiable de los datos que la La API de Fleet Engine Deliveries aumenta por ti.

Para administrar los ciclos de vida de los vehículos y las tareas en tu sistema, usa la API de Fleet Engine Deliveries para crear, actualizar y hacer un seguimiento de tus vehículos y sus tareas asociadas.

Al mismo tiempo, la aplicación del controlador se comunica directamente con Fleet Engine para actualizar la ubicación del dispositivo y la información de ruta. Este modelo permite que Fleet Engine administrar de forma eficiente la ubicación en tiempo real. Envía la ubicación directamente al de seguimiento de conversiones de Google, que puedes usar para informar a los consumidores sobre el estado de su pedido.

Por ejemplo, supongamos que se te presenta la siguiente situación:

• Un conductor se acerca a una parada de entrega. La aplicación del controlador envía su ubicación al Fleet Engine.
• Fleet Engine envía la ubicación del dispositivo a la la biblioteca de seguimiento que tu aplicación de consumidor usa para alertar al consumidor a la proximidad del paquete.
• Una vez que el conductor completa el envío, hace clic en “Envío entregado”. de la aplicación del controlador.
• El campo "Envío entregado" envía la información a tu sistema backend que realiza los pasos necesarios de validación y verificación de la empresa.
• Tu sistema confirma la tarea como SUCCEEDED y actualiza Fleet Engine a través del API de entrega.

En el siguiente diagrama, se ilustran estos procesos a un nivel genérico. También muestra la relación estándar entre tu sistema, el cliente y Fleet Engine.

Administrar tokens de cliente

Actualizaciones de ubicación que se originan en la aplicación del controlador y se envían directamente a Fleet Engine se requieran tokens de autorización. Este es el enfoque recomendado para manejar las actualizaciones del cliente a Fleet Engine:

1. Genera el token con el Usuario de controlador no confiable de entrega de Flet Engine. el rol de cuenta de servicio.

2. Proporciona a la aplicación del controlador un token de permiso limitado. Este permiso solo le permite actualizar la ubicación del dispositivo en Fleet Engine.

Este enfoque garantiza que las llamadas que se originan en un dispositivo móvil se consideren entornos de baja confianza, cumple con las principio de privilegio mínimo.

Otros roles de la cuenta de servicio

Si, en cambio, deseas autorizar a las aplicaciones del controlador para que hagan Fleet Engine realiza actualizaciones más allá de las restringidas al rol de controlador no confiable como para ciertas actualizaciones de tareas, puedes usar el rol de conductor de confianza. Para sobre un modelo que usa el rol de conductor de confianza, consulta Modelo de controlador de confianza.

Para obtener más información sobre los usos de los roles de controlador no confiables y confiables, consulta Configuración del proyecto de Cloud.

Modelar un día laboral

En la siguiente tabla, se describe la jornada laboral de los conductores de primera o última milla. en una empresa de entregas y logística. Tu empresa podría difieren en los detalles, pero puedes ver cómo podrías modelar un día laboral.

Cómo funcionan las actualizaciones de ubicación

Para obtener el mejor rendimiento con Fleet Engine, proporciónalo con una transmisión de vehículos las actualizaciones de ubicación. Usa cualquiera de las siguientes formas para proporcionar estas actualizaciones:

1. Usa el SDK de Driver: Android iOS -- es la opción más sencilla.
2. Utilizar un código personalizado, útil si las ubicaciones son se retransmiten mediante tu backend o si usas dispositivos que no sean Android iOS

Sin importar cómo proporciones actualizaciones de la ubicación del vehículo, tu backend es responsable de actualizar Fleet Engine cuando se carga dirigirse a una parada (incluido el depósito) y cuando llega a una parada. Fleet Engine no detecta estos eventos automáticamente.

Paradas y ubicaciones de entrega de vehículos

La parada de un vehículo es cuando un vehículo de reparto completa una tarea de envío o alguna otra tarea. Puede ser un punto de acceso, como un conector de carga o un ubicación asombrosa en la ruta.

La ubicación de entrega es aquella donde se entrega el envío o retirarse. Es posible que tengas que caminar un poco para ir y volver al lugar de entrega de la parada del vehículo.

Por ejemplo, cuando un conductor entrega un envío a la tienda de un centro comercial, el vehículo de reparto se detiene en el estacionamiento del centro comercial la entrada más cercana a la tienda. Esta es la parada del vehículo. El conductor luego camina desde la parada del vehículo hasta la ubicación dentro del centro comercial donde se encuentra la tienda. Esta es la ubicación de entrega.

Para obtener la mejor experiencia de seguimiento de envíos para los usuarios, considera de qué manera las tareas de envío se asignan a las paradas de los vehículos. Tenga en cuenta que la cantidad de se informa al usuario las paradas restantes del vehículo para las tareas de envío para ayudarlo ver el progreso del envío.

Por ejemplo, si un conductor hace muchas entregas en un solo edificio de oficinas, considera asignar todas las tareas de entrega a una sola parada del vehículo. Si cada tarea de entrega se asigna a su propia parada del vehículo, tu paquete de experiencia de seguimiento sería menos útil para tus usuarios, ya que el seguimiento es solo disponible una vez que el vehículo se encuentre en una cantidad limitada de paradas antes de su destino. El hecho de que muchas paradas del vehículo se hagan en poco tiempo no al usuario mucho tiempo para hacer un seguimiento del progreso de su entrega.

Cómo usar los SDK para dispositivos móviles

Antes de realizar llamadas al SDK del controlador, asegúrate de inicializarlo.

Cómo inicializar la API de Delivery Driver

Antes de inicializar la API de Delivery Driver en el SDK del controlador, asegúrate de que para inicializar el SDK de Navigation. Luego, inicializa la API de Delivery Driver como se muestra en el siguiente ejemplo:

static final String PROVIDER_ID = "provider-1234";
static final String VEHICLE_ID = "vehicle-8241890";

NavigationApi.getNavigator(
   this, // Activity.
   new NavigatorListener() {
     @Override
     public void onNavigatorReady(Navigator navigator) {
       DeliveryDriverApi.createInstance(DriverContext.builder(getApplication())
         .setNavigator(navigator)
         .setProviderId(PROVIDER_ID)
         .setVehicleId(VEHICLE_ID)
         .setAuthTokenFactory((context) -> "JWT") // AuthTokenFactory returns JWT for call context.
         .setRoadSnappedLocationProvider(NavigationApi.getRoadSnappedLocationProvider(getApplication()))
         .setNavigationTransactionRecorder(NavigationApi.getNavigationTransactionRecorder(getApplication()))
         .setStatusListener((statusLevel,statusCode,statusMsg) -> // Optional, surfaces polling errors.
             Log.d("TAG", String.format("New status update. %s, %s, %s", statusLevel, statusCode, statusMsg)))
         .build));
     }
     @Override
     public void onError(int errorCode) {
       Log.e("TAG", String.format("Error loading Navigator instance: %s", errorCode));
     }
   });

Casos de uso

En esta sección, se describe cómo usar la API de Deliveries para modelar casos de uso comunes.

Identificadores de entidad única

El formato y el valor de los identificadores de entidades únicos que se usan en las llamadas a REST son los siguientes: opaco a Fleet Engine. Evita usar IDs de incremento automático y asegúrate de que el identificador no contiene información de identificación personal (PII), como el número de teléfono del conductor.

Crea un vehículo

Puedes crear un vehículo desde SDK del controlador o desde un entorno de servidor con gRPC o REST.

gRPC

Para crear un vehículo nuevo, debes realizar una llamada CreateDeliveryVehicle a Fleet Engine. Usa el objeto CreateDeliveryVehicleRequest para definir los atributos de el nuevo vehículo de reparto. Ten en cuenta que cualquier valor que se especifique para el campo Name Se ignora según la guía de la API para los IDs especificados por el usuario. Debes usar el campo DeliveryVehicleId para configurar el ID del vehículo.

Cuando creas un DeliveryVehicle, tienes la opción de especificar estos campos:

• Atributos
• LastLocation
• Tipo

No establezcas ningún otro campo. Si lo haces, Fleet Engine mostrará un error ya que esos campos son de solo lectura o solo se pueden actualizar con una llamada a UpdateDeliveryVehicle

Para crear un vehículo sin configurar ningún campo opcional, puedes salir de la No se configuró el campo DeliveryVehicle en CreateDeliveryVehicleRequest.

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java Para crear un vehículo, sigue estos pasos:

    static final String PROJECT_ID = "my-delivery-co-gcp-project";
    static final String VEHICLE_ID = "vehicle-8241890"; // Avoid auto-incrementing IDs.

    DeliveryServiceBlockingStub deliveryService =
      DeliveryServiceGrpc.newBlockingStub(channel);

    // Vehicle settings
    String parent = "providers/" + PROJECT_ID;
    DeliveryVehicle vehicle = DeliveryVehicle.newBuilder()
      .addAttributes(DeliveryVehicleAttribute.newBuilder()
        .setKey("route_number").setValue("1"))  // Opaque to the Fleet Engine
      .build();

    // Vehicle request
    CreateDeliveryVehicleRequest createVehicleRequest =
      CreateDeliveryVehicleRequest.newBuilder()  // No need for the header
          .setParent(parent)
          .setDeliveryVehicleId(VEHICLE_ID)     // Vehicle ID assigned by the Provider
          .setDeliveryVehicle(vehicle)
          .build();

    // Error handling
    // If Fleet Engine does not have vehicle with that ID and the credentials of the
    // requestor pass, the service creates the vehicle successfully.

    try {
      DeliveryVehicle createdVehicle =
        deliveryService.createDeliveryVehicle(createVehicleRequest);
    } catch (StatusRuntimeException e) {
      Status s = e.getStatus();
      switch (s.getCode()) {
         case ALREADY_EXISTS:
           break;
         case PERMISSION_DENIED:
           break;
      }
      return;
    }

REST

Para crear un vehículo a partir de un entorno de servidor, realiza una llamada REST HTTP a CreateDeliveryVehicle:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles?deliveryVehicleId=<id>

<id> es un identificador único para un vehículo de entrega de tu flota.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de POST representa la entidad DeliveryVehicle que se creará. Puedes especificar los siguientes campos opcionales:

• attributes
• lastLocation
• tipo

Comando curl de ejemplo

# Set $JWT, $PROJECT_ID, and $VEHICLE_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?deliveryVehicleId=${VEHICLE_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
--data-binary @- << EOM
{
  "attributes": [{"key": "model", "value": "sedan"}],
  "lastLocation": {"location": {"latitude": 12.1, "longitude": 14.5}}
}
EOM

Fleet Engine ignora el campo name de la entidad DeliveryVehicle según la orientación de la API para los IDs especificados por el usuario. No establezcas ningún otro campo. Si lo haces, Fleet Engine mostrará un error debido a que esos campos son de solo lectura o solo se pueden actualizar con una llamada a UpdateDeliveryVehicle

Para crear un vehículo sin configurar ningún campo, abandona el cuerpo de la solicitud POST. la solicitud está vacía. Luego, el vehículo recién creado extrae un ID de vehículo del deliveryVehicleId en la URL de POST.

Comando curl de ejemplo

# Set $JWT, $PROJECT_ID, and $VEHICLE_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?deliveryVehicleId=${VEHICLE_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}"

Crear una tarea de retiro de envío

Puede crear una tarea de retiro del envío desde SDK de Driver o desde un entorno de servidor con gRPC o REST.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java Para crear una tarea de retiro del envío:

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.PICKUP)
  .setState(Task.State.OPEN)
  .setTrackingId("my-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .addAttributes(TaskAttribute.newBuilder().setKey("foo").setStringValue("value"))
  .addAttributes(TaskAttribute.newBuilder().setKey("bar").setNumberValue(10))
  .addAttributes(TaskAttribute.newBuilder().setKey("baz").setBoolValue(false))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have a task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para crear una tarea de retiro de envíos desde un entorno de servidor, realiza una llamada REST de HTTP a CreateTask:

`POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>`

&lt;id&gt; es un identificador único de la tarea. No debe ser el número de seguimiento para el envío. Si no tienes IDs de tareas en tu sistema, puedes generar un identificador único universal (UUID).

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  tipo	Type.PICKUP
  state	State.OPEN
  trackingId	Es el número o identificador que utiliza para realizar el seguimiento de un envío.
  plannedLocation	La ubicación donde se debe completar la tarea, en este caso la ubicación de recogida del envío.
  taskDuration	El tiempo esperado, en segundos, que tarda en retirar el envío en el lugar de recogida.

• Campos opcionales:

  Campo	Valor
  targetTimeWindow	El período durante el cual se debe completar la tarea. Esto no afectan el comportamiento del enrutamiento.
  attributes	Una lista de atributos de tareas personalizadas. Cada atributo debe tener una clave única.

Todos los demás campos de la entidad se ignoran para la creación. Fleet Engine lanza una excepción si la solicitud incluye un deliveryVehicleId asignado. Tú asignas tareas con UpdateDeliveryVehicleRequest. Para obtener más información, consulta Asigna tareas a un vehículo y UpdateDeliveryVehicleRequest.

Comando curl de ejemplo

# Set $JWT, $PROJECT_ID, $TRACKING_ID, and $TASK_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "PICKUP",
  "state": "OPEN",
  "trackingId": "${TRACKING_ID}",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "90s",
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Crear una tarea de entrega de envíos

Crea una tarea de entrega de envíos desde SDK del controlador o desde un entorno de servidor con gRPC o REST.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java Para crear una tarea de entrega de envíos:

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.DELIVERY)
  .setState(Task.State.OPEN)
  .setTrackingId("my-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .addAttributes(TaskAttribute.newBuilder().setKey("foo").setStringValue("value"))
  .addAttributes(TaskAttribute.newBuilder().setKey("bar").setNumberValue(10))
  .addAttributes(TaskAttribute.newBuilder().setKey("baz").setBoolValue(false))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para crear una tarea de entrega de envíos desde un entorno de servidor con gRPC o REST, realiza una llamada REST de HTTP a CreateTask:

`POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>`

&lt;id&gt; es un identificador único de la tarea. No debe ser el número de seguimiento para el envío. Si no tienes IDs de tareas en tu sistema, puedes generar un identificador único universal (UUID).

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  tipo	Type.DELIVERY
  state	State.OPEN
  trackingId	Es el número o identificador que utiliza para realizar el seguimiento de un envío.
  plannedLocation	La ubicación donde se debe completar la tarea, en este caso la ubicación de entrega de este envío.
  taskDuration	Es el tiempo esperado, en segundos, que tomará dejar el envío. en la ubicación de entrega.

• Campos opcionales:

  Campo	Valor
  targetTimeWindow	El período durante el cual se debe completar la tarea. Esto no afectan el comportamiento del enrutamiento.
  attributes	Una lista de atributos de tareas personalizadas. Cada atributo debe tener una clave única.

Todos los demás campos de la entidad se ignoran para la creación. Fleet Engine lanza una excepción si la solicitud incluye un deliveryVehicleId asignado. Tú asignas tareas con UpdateDeliveryVehicleRequest. Para obtener más información, consulta Asigna tareas a un vehículo y UpdateDeliveryVehicleRequest.

Comando curl de ejemplo

# Set $JWT, $PROJECT_ID, $TRACKING_ID, and $TASK_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "DELIVERY",
  "state": "OPEN",
  "trackingId": "${TRACKING_ID}",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "90s",
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Tareas de creación por lotes

Puedes crear un lote de tareas desde un entorno de servidor con gRPC o REST.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java crear dos tareas, una para una entrega y otra para un retiro al mismo tiempo ubicación:

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Delivery Task settings
Task deliveryTask = Task.newBuilder()
  .setType(Task.Type.DELIVERY)
  .setState(Task.State.OPEN)
  .setTrackingId("delivery-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Delivery Task request
CreateTaskRequest createDeliveryTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header or parent fields
      .setTaskId("task-8312508")  // Task ID assigned by the Provider
      .setTask(deliveryTask)      // Initial state
      .build();

// Pickup Task settings
Task pickupTask = Task.newBuilder()
  .setType(Task.Type.PICKUP)
  .setState(Task.State.OPEN)
  .setTrackingId("pickup-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Pickup Task request
CreateTaskRequest createPickupTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header or parent fields
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(pickupTask)        // Initial state
      .build();

// Batch Create Tasks settings
String parent = "providers/" + PROJECT_ID;

// Batch Create Tasks request
BatchCreateTasksRequest batchCreateTasksRequest =
  BatchCreateTasksRequest.newBuilder()
      .setParent(parent)
      .addRequests(createDeliveryTaskRequest)
      .addRequests(createPickupTaskRequest)
      .build();

// Error handling
// If Fleet Engine does not have any task(s) with these task ID(s) and the
// credentials of the requestor pass, the service creates the task(s)
// successfully.

try {
  BatchCreateTasksResponse createdTasks = deliveryService.batchCreateTasks(
    batchCreateTasksRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para crear una tarea de entrega y retiro desde un entorno de servidor, crea una Llamada de REST de HTTP a BatchCreateTasks:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks:batchCreate

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer. <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad BatchCreateTasksRequest:

• Campos obligatorios:

  Campo	Valor
  solicitudes	Arreglo<CreateTasksRequest>

• Campos opcionales:

  Campo	Valor
  encabezado	`DeliveryRequestHeader`

Cada elemento CreateTasksRequest de requests debe pasar la misma validación reglas como una solicitud CreateTask, con la excepción de que parent y header son opcionales. Si se establecen, deben ser idénticos a sus respectivos campos en el nivel superior BatchCreateTasksRequest. Consulta crear una tarea de retiro del envío crear una tarea de entrega de envíos para ver las reglas de validación específicas para cada uno.

Para obtener más información, consulta la documentación de referencia de la API para BatchCreateTasks (gRPC, REST).

Comando curl de ejemplo

# Set $JWT, $PROJECT_ID, $DELIVERY_TRACKING_ID, $DELIVERY_TASK_ID,
# $PICKUP_TRACKING_ID, and $PICKUP_TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks:batchCreate" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "requests" : [
    {
      "taskId": "${DELIVERY_TASK_ID}",
      "task" : {
        "type": "DELIVERY",
        "state": "OPEN",
        "trackingId": "${DELIVERY_TRACKING_ID}",
        "plannedLocation": {
          "point": {
              "latitude": -6.195139,
              "longitude": 106.820826
          }
        },
        "taskDuration": "90s"
      }
    },
    {
      "taskId": "${PICKUP_TASK_ID}",
      "task" : {
        "type": "PICKUP",
        "state": "OPEN",
        "trackingId": "${PICKUP_TRACKING_ID}",
        "plannedLocation": {
          "point": {
              "latitude": -6.195139,
              "longitude": 106.820826
          }
        },
        "taskDuration": "90s"
      }
    }
  ]
}
EOM

Falta de disponibilidad programada

Puedes crear una tarea que indique la falta de disponibilidad (por ejemplo, para quiebres o recarga de combustible) desde el SDK del controlador, o desde un entorno de servidor con gRPC o REST. Una tarea de falta de disponibilidad programada no debe incluir un ID de seguimiento. De manera opcional, puedes proporcionar una ubicación.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para crear una tarea de falta de disponibilidad:

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

    DeliveryServiceBlockingStub deliveryService =
      DeliveryServiceGrpc.newBlockingStub(channel);

    // Task settings
    String parent = "providers/" + PROJECT_ID;
    Task task = Task.newBuilder()
      .setType(Task.Type.UNAVAILABLE)
      .setState(Task.State.OPEN)
      .setTaskDuration(
        Duration.newBuilder().setSeconds(60 * 60))  // 1hr break
      .build();

    // Task request
    CreateTaskRequest createTaskRequest =
      CreateTaskRequest.newBuilder()  // No need for the header
          .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
          .setTaskId("task-8241890")  // Task ID assigned by the Provider
          .setTask(task)              // Initial state
          .build();

    // Error handling
    // If Fleet Engine does not have task with that ID and the credentials of the
    // requestor pass, the service creates the task successfully.

    try {
      Task createdTask = deliveryService.createTask(createTaskRequest);
    } catch (StatusRuntimeException e) {
      Status s = e.getStatus();
      switch (s.getCode()) {
         case ALREADY_EXISTS:
           break;
         case PERMISSION_DENIED:
           break;
      }
      return;
    }

REST

Para crear una tarea de falta de disponibilidad desde un entorno de servidor, realiza una llamada REST de HTTP a CreateTask:

`POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>`

&lt;id&gt; es un identificador único de la tarea. Si no ID de tarea en tu sistema, puedes generar un ID único único (UUID).

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  tipo	Type.UNAVAILABLE
  state	State.OPEN
  taskDuration	Es la duración de la pausa en segundos.

• Campos opcionales:

  Campo	Valor
  plannedLocation	La ubicación de la pausa si debe tomarse en una ubicación específica.

Todos los demás campos de la entidad se ignoran para la creación. Fleet Engine lanza una excepción si la solicitud incluye un deliveryVehicleId asignado. Tú asignas tareas con UpdateDeliveryVehicleRequest. Para obtener más información, consulta Asigna tareas a un vehículo y UpdateDeliveryVehicleRequest.

Comando curl de ejemplo

    # Set $JWT, $PROJECT_ID, and $TASK_ID in the local environment
    curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
      -H "Content-type: application/json" \
      -H "Authorization: Bearer ${JWT}" \
      --data-binary @- << EOM
    {
      "type": "UNAVAILABLE",
      "state": "OPEN",
      "plannedLocation": {
         "point": {
            "latitude": -6.195139,
            "longitude": 106.820826
         }
      },
      "taskDuration": "300s"
    }
    EOM

Paradas programadas

Puedes crear una tarea de detención programada desde SDK del controlador, o desde un entorno de servidor con gRPC o REST. Es posible que una tarea de detención programada no incluya un seguimiento ID.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para crear una tarea de detención programada:

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.SCHEDULED_STOP)
  .setState(Task.State.OPEN)
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTrip(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para crear una tarea de detención programada desde un entorno de servidor, realiza una llamada REST HTTP a CreateTask:

`POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>`

&lt;id&gt; es un identificador único de la tarea. Si no tienes IDs de tareas en tu sistema, puedes generar un identificador único universal (UUID).

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  tipo	Type.SCHEDULED_STOP
  state	State.OPEN
  plannedLocation	Es la ubicación de la parada.
  taskDuration	Es la duración prevista de la parada en segundos.

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran para la creación. Fleet Engine lanza una excepción si la solicitud incluye un deliveryVehicleId asignado. Tú asignas tareas con UpdateDeliveryVehicleRequest. Para obtener más información, consulta Asigna tareas a un vehículo y UpdateDeliveryVehicleRequest.

Comando curl de ejemplo

    # Set $JWT, $PROJECT_ID, and $TASK_ID in the local environment
    curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
      -H "Content-type: application/json" \
      -H "Authorization: Bearer ${JWT}" \
      --data-binary @- << EOM
    {
      "type": "SCHEDULED_STOP",
      "state": "OPEN",
      "plannedLocation": {
         "point": {
            "latitude": -6.195139,
            "longitude": 106.820826
         }
      },
      "taskDuration": "600s"
    }
    EOM

Establecer período objetivo

El período objetivo es el TimeWindow durante el cual la tarea debe completarse. Por ejemplo, si comunicas una tiempo de entrega a los destinatarios de la entrega, puedes usar el tiempo para captar este margen de tiempo y generar alertas o analizar el período posterior al viaje rendimiento usando el campo.

El período objetivo consta de una hora de inicio y una de finalización, y se puede establecer para cualquier tipo de tarea. El período objetivo no afecta el enrutamiento el comportamiento de los usuarios.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java Para establecer un período para las tareas, haz lo siguiente:

    static final String PROJECT_ID = "my-delivery-co-gcp-project";
    static final String TASK_ID = "task-8241890";

    DeliveryServiceBlockingStub deliveryService =
      DeliveryServiceGrpc.newBlockingStub(channel);

    // Task settings
    String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
    Task task = Task.newBuilder()
      .setName(taskName)
      .setTargetTimeWindow(
        TimeWindow.newBuilder()
          .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
          .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
      .build();

    // Task request
    UpdateTaskRequest updateTaskRequest =
      UpdateTaskRequest.newBuilder()  // No need for the header
          .setTask(task)
          .setUpdateMask(FieldMask.newBuilder().addPaths("targetTimeWindow"))
          .build();

    try {
      Task updatedTask = deliveryService.updateTask(updateTaskRequest);
    } catch (StatusRuntimeException e) {
      Status s = e.getStatus();
      switch (s.getCode()) {
         case NOT_FOUND:
           break;
         case PERMISSION_DENIED:
           break;
      }
      return;
    }

REST

Para establecer un período de tarea con HTTP, llama a UpdateTask:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=targetTimeWindow`

&lt;id&gt; es un identificador único de la tarea.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  targetTimeWindow	El período durante el cual se debe completar la tarea. Este parámetro de configuración no afecta el comportamiento del enrutamiento

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=targetTimeWindow" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Establece la configuración de visibilidad del seguimiento de tareas

La visibilidad de los datos en la biblioteca de Shipment Tracking y de esos datos que se muestra desde una llamada a GetTaskTrackingInfo pueden controlarse en una tarea base al establecer un TaskTrackingViewConfig en la tarea. Consulta Tareas activas en vehículos para obtener más información. Esto se puede hacer al crear o actualizar tarea. El siguiente es un ejemplo de actualización de la tarea con esta configuración:

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para establecer la configuración de la vista de seguimiento de tareas:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTaskTrackingViewConfig(
    TaskTrackingViewConfig.newBuilder()
      .setRoutePolylinePointsVisibility(
        VisibilityOption.newBuilder().setRemainingStopCountThreshold(3))
      .setEstimatedArrivalTimeVisibility(
        VisibilityOption.newBuilder().remainingDrivingDistanceMetersThreshold(5000))
      .setRemainingStopCountVisibility(
        VisibilityOption.newBuilder().setNever(true)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("taskTrackingViewConfig"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
      case NOT_FOUND:
        break;
      case PERMISSION_DENIED:
        break;
  }
  return;
}

REST

Para establecer la ventana de configuración de la vista de seguimiento de tareas con HTTP, llama a UpdateTask:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=taskTrackingViewConfig`

&lt;id&gt; es un identificador único de la tarea.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  taskTrackingViewConfig	La configuración del seguimiento de tareas que especifica qué elementos de datos son visibles para los usuarios finales en qué circunstancias.

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=taskTrackingViewConfig" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "taskTrackingViewConfig": {
    "routePolylinePointsVisibility": {
      "remainingStopCountThreshold": 3
    },
    "estimatedArrivalTimeVisibility": {
      "remainingDrivingDistanceMetersThreshold": 5000
    },
    "remainingStopCountVisibility": {
      "never": true
    }
  }
}
EOM

Asigna tareas a un vehículo

Para asignar tareas a un vehículo de entrega, actualiza el orden de las tareas. para el vehículo. El orden de las tareas para un vehículo está determinado por la lista de paradas vehiculares para el vehículo de reparto, y puedes asignar una o más tareas a cada parada del vehículo. Para obtener más información, consulta Actualiza el orden de las tareas.

Para cambiar un envío de un vehículo a otro, cierra la tarea original. y, luego, volver a crearla antes de asignarle el nuevo vehículo. Si actualizas la tarea ordenar una tarea que ya está asignada a un vehículo diferente, recibirás un error.

Actualizar el orden de las tareas

Puedes actualizar el orden en el que se realizan las tareas asignadas a un vehículo desde el SDK del controlador, o el entorno del servidor. No uses ambos métodos para evitar las condiciones raciales y mantener una única fuente de verdad.

Cuando actualizas el pedido de tareas de un vehículo, también se hace lo siguiente:

• Asigna tareas que son nuevas en el vehículo.
• Cierra las tareas que se asignaron anteriormente al vehículo, pero que ya no están en el orden actualizado.

Para cambiar un envío de un vehículo a otro, cerrar la tarea original y, luego, volver a crearla antes de asignarle el nuevo vehículo. Si actualizas la tarea ordenar una tarea que ya está asignada a un vehículo diferente, recibirás un error.

Puedes actualizar el orden de las tareas en cualquier momento.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para actualizar el orden de las tareas del vehículo:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";
static final String TASK1_ID = "task-756390";
static final String TASK2_ID = "task-849263";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 1st stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.NEW)))
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder().addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para actualizar el pedido de tareas para un vehículo desde un entorno de servidor, realiza una llamada REST HTTP a UpdateDeliveryVehicle:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments`

&lt;id&gt; es un identificador único de un vehículo de entrega de tu flota. para el que tienes la intención de actualizar el orden de las tareas. Es el identificador que que especificaste cuando creaste el vehículo.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad DeliveryVehicle:

• Campos obligatorios:

  Campo	Valor
  remainingVehicleJourneySegments	Una lista de segmentos de recorrido para las tareas en el orden en que deben ejecutarse. La primera tarea de la lista se ejecuta primero.
  remainingVehicleJourneySegments[i].stop	La parada de la tarea i en la lista.
  remainingVehicleJourneySegments[i].stop.plannedLocation	Es la ubicación planificada para la parada.
  remainingVehicleJourneySegments[i].stop.tasks	Una lista de tareas que se deben realizar en esta parada del vehículo.
  remainingVehicleJourneySegments[i].stop.state	State.NEW

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

El vehículo está en camino a la siguiente parada

Fleet Engine debe recibir una notificación cuando un vehículo sale de una parada o comienza la navegación. Puedes notificar a Fleet Engine desde el SDK del controlador, o desde un entorno de servidor con gRPC o REST. No usar ambos métodos para evitar una raza y mantener una única fuente de verdad.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para notificar a Fleet Engine que un vehículo está en camino a su próxima parada.

    static final String PROJECT_ID = "my-delivery-co-gcp-project";
    static final String VEHICLE_ID = "vehicle-8241890";

    DeliveryServiceBlockingStub deliveryService =
      DeliveryServiceGrpc.newBlockingStub(channel);

    // Vehicle settings
    DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
        // Next stop marked as ENROUTE
        .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 1st stop
           .setStop(VehicleStop.newBuilder()
               .setPlannedLocation(LocationInfo.newBuilder()
                   .setPoint(LatLng.newBuilder()
                       .setLatitude(37.7749)
                       .setLongitude(122.4194)))
               .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
               .setState(VehicleStop.State.ENROUTE)))
        // All other stops marked as NEW
        .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
           .setStop(VehicleStop.newBuilder()
               .setPlannedLocation(LocationInfo.newBuilder()
                   .setPoint(LatLng.newBuilder()
                       .setLatitude(37.3382)
                       .setLongitude(121.8863)))
               .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
               .setState(VehicleStop.State.NEW)))
        .build();

    // DeliveryVehicle request
    UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
      UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
          .setName(vehicleName)
          .setDeliveryVehicle(deliveryVehicle)
          .setUpdateMask(FieldMask.newBuilder().addPaths("remaining_vehicle_journey_segments"))
          .build();

    try {
      DeliveryVehicle updatedDeliveryVehicle =
          deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
    } catch (StatusRuntimeException e) {
      Status s = e.getStatus();
      switch (s.getCode()) {
         case NOT_FOUND:
           break;
         case PERMISSION_DENIED:
           break;
      }
      return;
    }

REST

Para notificar a Fleet Engine que un vehículo está en camino a su próxima parada desde un entorno del servidor, realiza una llamada REST de HTTP a UpdateDeliveryVehicle:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments`

&lt;id&gt; es un identificador único para el vehículo de entrega de tu flota. para el que tienes la intención de actualizar el orden de las tareas. Es el identificador que que especificaste cuando creaste el vehículo.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad DeliveryVehicle:

• Campo obligatorio:

  Campo	Valor
  remainingVehicleJourneySegments	Lista de paradas vehiculares restantes con sus estados marcados como State.NEW. La primera parada de la lista debe tener su estado marcado como State.ENROUTE.

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran en la notificación.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "ENROUTE",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Actualiza la ubicación del vehículo

Si no usas el SDK del conductor para actualizar la ubicación del vehículo, puedes crear una llamada directa a Fleet Engine con la ubicación del vehículo. Para cualquier vehículo activo, Fleet Engine espera una actualización de la ubicación al menos una vez por minuto y como máximo una vez cada 5 segundos.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java Para actualizar la ubicación de un vehículo en Fleet Engine, sigue estos pasos:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle myDeliveryVehicle = DeliveryVehicle.newBuilder()
    .setLastLocation(DeliveryVehicleLocation.newBuilder()
        .setSupplementalLocation(LatLng.newBuilder()
            .setLatitude(37.3382)
            .setLongitude(121.8863))
        .setSupplementalLocationTime(now())
        .setSupplementalLocationSensor(DeliveryVehicleLocationSensor.CUSTOMER_SUPPLIED_LOCATION)
        .setSupplementalLocationAccuracy(DoubleValue.of(15.0)))  // Optional
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(myDeliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("last_location"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para actualizar la ubicación de un vehículo en Fleet Engine con REST HTTP, realiza una llamada al UpdateDeliveryVehicle:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=last_location`

&lt;id&gt; es un identificador único del vehículo de entrega en tu de la flota o en los que planeas actualizar la ubicación. Es el identificador que que especificaste cuando creaste el vehículo.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad DeliveryVehicle:

• Campo obligatorio:

  Campo	Valor
  lastLocation.supplementalLocation	La ubicación del vehículo.
  lastLocation.supplementalLocationTime	La última marca de tiempo conocida en la que el vehículo estuvo en esta ubicación.
  lastLocation.supplementalLocationSensor	Se debe completar con CUSTOMER_SUPPLIED_LOCATION.

• Campos opcionales:

  Campo	Valor
  lastLocation.supplementalLocationAccuracy	Precisión de la ubicación proporcionada, en metros.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "lastLocation": {
    "supplementalLocation": {"latitude": 12.1, "longitude": 14.5},
    "supplementalLocationTime": "$(date -u --iso-8601=seconds)",
    "supplementalLocationSensor": "CUSTOMER_SUPPLIED_LOCATION",
    "supplementalLocationAccuracy": 15
  }
}
EOM

El vehículo llega a una parada

Fleet Engine debe recibir una notificación cuando un vehículo llega a una parada. Puedes notificar Fleet Engine, ya sea desde SDK del controlador, o desde un entorno de servidor con gRPC o REST. No usar ambos métodos para evitar una raza y mantener una única fuente de verdad.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para notificar a Fleet Engine que un vehículo llegó a una parada:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // Marking the arrival at stop.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.ARRIVED)))
    // All other remaining stops marked as NEW.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW))) // Remaining stops must be NEW.
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para notificar a Fleet Engine sobre la llegada de un vehículo a una parada desde un entorno de servidor, Realiza una llamada REST de HTTP a UpdateDeliveryVehicle:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments`

&lt;id&gt; es un identificador único para el vehículo de entrega de tu flota. para el que tienes la intención de actualizar el orden de las tareas. Es el identificador que que especificaste cuando creaste el vehículo.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad DeliveryVehicle:

• Campos obligatorios:

  Campo	Valor
  remainingVehicleJourneySegments	La parada a la que llegaste con su estado establecido como State.ARRIVED, seguido de una lista de las paradas vehiculares restantes con sus estados marcados como State.NEW.

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "ARRIVED",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

El vehículo completa una parada

Fleet Engine debe recibir una notificación cuando un vehículo finaliza una parada. Esto provoca todas las tareas asociadas con la parada se establecerán en el estado CLOSED. Puedes notificar a Fleet Engine, ya sea desde SDK del controlador, o desde un entorno de servidor con gRPC o REST. No uses ambos métodos para evitar condiciones de carrera y mantener una única fuente de verdad.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para notificar a Fleet Engine que un vehículo se detuvo.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // This stop has been completed and is commented out to indicate it
    // should be removed from the list of vehicle journey segments.
    // .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()
    //    .setStop(VehicleStop.newBuilder()
    //        .setPlannedLocation(LocationInfo.newBuilder()
    //            .setPoint(LatLng.newBuilder()
    //                .setLatitude(37.7749)
    //                .setLongitude(122.4194)))
    //        .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
    //        .setState(VehicleStop.State.ARRIVED)))
    // All other remaining stops marked as NEW.
    // The next stop could be marked as ENROUTE if the vehicle has begun
    // its journey to the next stop.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // Next stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // no need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para notificar a Fleet Engine sobre la finalización de una parada desde un entorno de servidor, Realiza una llamada REST de HTTP a UpdateDeliveryVehicle:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remaining_vehicle_journey_segments`

&lt;id&gt; es un identificador único para el vehículo de entrega de tu flota. para el que tienes la intención de actualizar el orden de las tareas. Es el identificador que que especificaste cuando creaste el vehículo.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad DeliveryVehicle:

• Campos obligatorios:

  Campo	Valor
  remaining_vehicle_journey_segments	La parada que has completado ya no debería estar en la lista de paradas restantes del vehículo.

• Campos opcionales:

  • Ninguno

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

    # Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
    # environment
    curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
      -H "Content-type: application/json" \
      -H "Authorization: Bearer ${JWT}" \
      --data-binary @- << EOM
    {
      "remainingVehicleJourneySegments": [
        {
          "stop": {
            "state": "NEW",
            "plannedLocation": {
              "point": {
                "latitude": 37.3382,
                "longitude": 121.8863
              }
            },
            "tasks": [
              {
                "taskId": "${TASK2_ID}"
              }
            ]
          }
        }
      ]
    }
    EOM

Actualizar una tarea

La mayoría de los campos de tareas son inmutables. Sin embargo, puedes modificar el estado, resultado de la tarea, tiempo de resultado de la tarea, ubicación del resultado de la tarea y atributos por actualizando directamente la entidad Task. Por ejemplo, en los casos en que una tarea no ha asignado a un vehículo, puedes cerrar la tarea actualizando el de forma directa.

gRPC

Este es un ejemplo de cómo actualizar una tarea con gRPC.

REST

Este es un ejemplo de cómo actualizar una tarea con REST.

Cómo cerrar una tarea

Para cerrar una tarea que se asignó a un vehículo, notifica a Fleet Engine que el vehículo completó la parada en la que se realiza la tarea. o quítalo de la lista de paradas del vehículo. Para ello, puedes establecer la lista de el vehículo restante se detiene al igual que cuando se actualiza el orden de la tarea. de un vehículo.

Si a una tarea aún no se asignó un vehículo y se debe cerrar, actualiza la tarea a un estado CLOSED. Sin embargo, no puedes volver a abrir una tarea CERRADA.

El cierre de una tarea no indica el éxito o el fracaso de la tarea. Indica que el tarea ya no se considera en curso. Para el seguimiento de envíos, es importante indicar el resultado real de una tarea para que una entrega puede mostrar un resultado positivo.

gRPC

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setState(Task.State.CLOSED) // You can only directly CLOSE a
  .build();                    // task that is NOT assigned to a vehicle.

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("state"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para marcar una tarea como cerrada desde el entorno de un servidor, realiza una llamada REST HTTP a UpdateTask:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=state`

&lt;id&gt; es un identificador único de la tarea.

El encabezado de tu solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

Debes incluir una entidad Task en el cuerpo de la solicitud:

• Campos obligatorios:

  Campo	Valor
  state	State.CLOSED

• Campos opcionales:

  Campo	Valor
  taskOutcome	Resultado.SUCCEEDED o resultado.FAILED
  taskOutcomeTime	La hora en la que se completó la tarea.
  taskOutcomeLocation	La ubicación donde se completó la tarea. Fleet Engine establece este valor de forma predeterminada hasta la última ubicación del vehículo, a menos que el proveedor lo anule manualmente

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

    # Set JWT, PROJECT_ID, and TASK_ID in the local environment
    curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=state,taskOutcome,taskOutcomeTime" \
      -H "Content-type: application/json" \
      -H "Authorization: Bearer ${JWT}" \
      --data-binary @- << EOM
    {
      "state": "CLOSED",
      "taskOutcome": "SUCCEEDED",
      "taskOutcomeTime": "$(date -u --iso-8601=seconds)"
    }
    EOM

Establecer el resultado de la tarea y su ubicación

El cierre de una tarea no indica el éxito o el fracaso, indica que la tarea ya no se considera en curso. Para el seguimiento de envíos, es importante indicar el resultado real de una tarea para que un el resultado de la entrega y la facturación de los servicios es adecuada. Una vez que se establece, no puedes cambiar el resultado de la tarea. Sin embargo, puedes modificar el el tiempo y la ubicación del resultado de la tarea después de que se hayan establecido.

Las tareas que están en estado CERRADO pueden tener el resultado configurado en EXITOSA o FALLIDA. Fleet Engine solo cobra las tareas de entrega con el estado de COMPLETA.

Cuando marcas el resultado de una tarea, Fleet Engine completa automáticamente los la ubicación del resultado de la tarea con la última ubicación conocida del vehículo. Puedes anulan este comportamiento.

gRPC

Tienes la opción de establecer la ubicación del resultado de la tarea cuando definas la resultado. Configurar la ubicación impide que Fleet Engine la configure al valor predeterminado de la última la ubicación del vehículo. También puedes reemplazar la ubicación del resultado de la tarea de Fleet Engine establecer en otro momento. Fleet Engine nunca reemplaza la ubicación de los resultados de una tarea que proporciones. No puedes establecer la ubicación del resultado de una tarea que no tiene un conjunto de resultados de tareas. Puedes establecer ambos resultados de la tarea y la ubicación del resultado de la tarea dentro de la misma solicitud.

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para establecer el resultado de una tarea como SUCCEEDED y establecer la ubicación donde se realizó completada:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTaskOutcome(TaskOutcome.SUCCEEDED)
  .setTaskOutcomeTime(now())
  .setTaskOutcomeLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("task_outcome", "task_outcome_time", "task_outcome_location"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para marcar una tarea como completada desde un entorno de servidor, Realiza una llamada REST de HTTP a UpdateTask:

`PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=taskOutcome,taskOutcomeTime,taskOutcomeLocation`

&lt;id&gt; es un identificador único de la tarea.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe contener una entidad Task:

• Campos obligatorios:

  Campo	Valor
  taskOutcome	Resultado.SUCCEEDED o resultado.FAILED

• Campos opcionales:

  Campo	Valor
  taskOutcomeLocation	La ubicación donde se completó la tarea. Si no se configura, Fleet Engine usa de forma predeterminada la última ubicación del vehículo.
  taskOutcomeTime	La marca de tiempo de cuando se completó la tarea.

Todos los demás campos de la entidad se ignoran para la actualización.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=taskOutcome,taskOutcomeTime,taskOutcomeLocation" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "taskOutcome": "SUCCEEDED",
  "taskOutcomeTime": "$(date -u --iso-8601=seconds)",
  "taskOutcomeLocation": {
    "point": {
      "latitude": -6.195139,
      "longitude": 106.820826
    }
  }
}
EOM

Redirigir un envío

Una vez que se crea una tarea de envío, no se puede cambiar su ubicación planificada. Para redirigir un envío, cierra la tarea de envío sin configurar un resultado y, a continuación, crea una tarea nueva con la ubicación planificada actualizada. Después de crear la tarea nueva, asígnala al mismo vehículo. Para ver más información, consulte cómo cerrar la tarea de envío y asignar la tarea.

Usar alimentadores y vehículos de reparto

Si usas vehículos de alimentación para transportar envíos a vehículos de entrega a lo largo del día, modelar la transferencia de envíos como una tarea de detención programada para el vehículo de entrega. Para garantizar un seguimiento de la ubicación exacto, asigna una tarea de entrega para un envío transferido después de que se haya cargado vehículo de reparto. Para obtener más información, consulta Parada programada.

Estado del envío de la tienda y otra metainformación

Cuando se completa una tarea de envío, se registran el estado y el resultado de la tarea en la tarea. Sin embargo, te recomendamos que actualices otra metainformación específicas del envío. Para almacenar otra metainformación que puedas fuera del servicio de Fleet Engine, usa el tracking_id asociado con la tarea como clave en una tabla externa.

Para obtener más información, consulta Ciclo de una tarea.

Buscar un vehículo

Puedes buscar un vehículo desde SDK del controlador, o desde un entorno de servidor con gRPC o REST.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para buscar un vehículo:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle request
String name = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
GetDeliveryVehicleRequest getVehicleRequest = GetDeliveryVehicleRequest.newBuilder()  // No need for the header
    .setName(name)
    .build();

try {
  DeliveryVehicle vehicle = deliveryService.getDeliveryVehicle(getVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para buscar un vehículo desde un entorno de servidor, Realiza una llamada REST de HTTP a GetVehicle:

`GET https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<vehicleId>`

&lt;id&gt; es un identificador único de la tarea.

&lt;vehicleId&gt; es el ID del vehículo que se debe buscar.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe estar vacío.

Si la búsqueda se realiza correctamente, el cuerpo de la respuesta contendrá una entidad de vehículo.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}"

Cómo buscar una tarea

Puedes buscar una tarea desde el entorno de un servidor con gRPC o REST. El SDK de Driver no ayuda a buscar una tarea.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para buscar una tarea:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8597549";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task request
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
GetTaskRequest getTaskRequest = GetTaskRequest.newBuilder()  // No need for the header
    .setName(taskName)
    .build();

try {
  Task task = deliveryService.getTask(getTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para buscar una tarea desde el entorno de un servidor, Realiza una llamada REST de HTTP a GetTask:

`GET https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<taskId>`

&lt;id&gt; es un identificador único de la tarea.

&lt;taskId&gt; es el ID de la tarea que se buscará.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

El cuerpo de la solicitud debe estar vacío.

Si la búsqueda se realiza correctamente, el cuerpo de la respuesta contendrá una entidad de tarea.

Comando curl de ejemplo

    # Set JWT, PROJECT_ID, and TASK_ID in the local environment
    curl -H "Authorization: Bearer ${JWT}" \
      "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}"

Buscar información de las tareas de envío por su ID de seguimiento

Puede buscar información de las tareas de envío de las siguientes maneras: cada uno de los cuales tiene un propósito diferente:

• por un ID de tarea: lo usan usuarios, como los operadores de flotas, que tienen acceso a la vista completa de los datos de la tarea.
• por un ID de seguimiento: El software del cliente lo usa para proporcionar limitaciones información a un usuario final, como cuándo se espera un paquete en su casa.

En esta sección, se analiza la búsqueda de información de tareas mediante un ID de seguimiento. Si quieres Para buscar una tarea por su ID, ve a Cómo buscar una tarea.

Para buscar información con un ID de seguimiento, puedes utilizar cualquiera de las siguientes opciones:

• Búsquedas con Java mediante gRPC
• Búsquedas con HTTP

Requisitos de búsqueda

• La información de envío proporcionada por un ID de seguimiento cumple con las reglas de visibilidad. se menciona en Controla la visibilidad de las ubicaciones que sigues.

• Usa Fleet Engine para buscar información de envío por ID de seguimiento. El conductor El SDK no admite las búsquedas de información por ID de seguimiento. Para hacer esto con Fleet Engine, usarás un entorno de servidor o de navegador.

• Usar el token más estrecho posible para limitar los riesgos de seguridad Por ejemplo, si usar un token de consumidor de entrega, cualquier llamada a la API de Fleet Engine Deliveries se muestre solo información relevante para ese usuario final, como el transportista o receptor de un envío. Se oculta el resto de la información de las respuestas. Para obtener más información sobre los tokens, consulta Crear un token web JSON (JWT) para autorización.

Búsquedas con Java mediante gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para buscar información sobre una tarea de envío por su ID de seguimiento.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TRACKING_ID = "TID-7449w087464x5";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
GetTaskTrackingInfoRequest getTaskTrackingInfoRequest = GetTaskTrackingInfoRequest.newBuilder()  // No need for the header
    .setParent(parent)
    .setTrackingId(TRACKING_ID)
    .build();

try {
  TaskTrackingInfo taskTrackingInfo = deliveryService.getTaskTrackingInfo(getTaskTrackingInfoRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

Búsquedas a través de HTTP

Para buscar una tarea de envío desde un navegador, realiza una llamada REST HTTP al GetTaskTrackingInfo:

`GET https://fleetengine.googleapis.com/v1/providers/<project_id>/taskTrackingInfo/<tracking_id>`

&lt;tracking_id&gt; es el ID de seguimiento asociado con la tarea.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

Si la búsqueda se realiza correctamente, el cuerpo de la respuesta contendrá un taskTrackingInfo .

Comando curl de ejemplo

# Set JWT, PROJECT_ID, and TRACKING_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/taskTrackingInfo/${TRACKING_ID}"

Enumerar tareas

Puedes enumerar tareas desde un entorno de servidor o navegador. El SDK de Driver no admite la enumeración de tareas.

Enumerar tareas solicita un acceso amplio a las tareas. Enumerar tareas está destinada solo a usuarios de confianza. Usa la autenticación de lectura de flota de entrega o de superusuario de entrega Tokens cuando se hacen solicitudes de lista de tareas.

Las tareas enumeradas tienen los siguientes campos ocultos:

• VehicleStop.planned_location
• VehicleStop.state
• VehicleStop.TaskInfo.taskId

Las tareas enumeradas se pueden filtrar por la mayoría de las propiedades de las tareas. Para la sintaxis de consulta de filtro, consulta AIP-160. En la siguiente lista, se muestran tareas válidas propiedades que puedes usar para filtrar:

• attributes
• delivery_vehicle_id
• state
• planned_location
• task_duration
• task_outcome
• task_outcome_location
• task_outcome_location_source
• task_outcome_time
• tracking_id
• tipo

Usa los siguientes formatos de campo según las propuestas de mejora de la API de Google:

Consulta AIP-160 para ver una lista completa de las consultas de filtro operadores.

Si no se especifica una consulta de filtro, se enumeran todas las tareas.

Las listas de tareas están paginadas. Se puede especificar un tamaño de página en las solicitudes de lista de tareas. Si se especifica un tamaño de página, la cantidad de tareas mostradas no será mayor que el tamaño de página especificado. Si no hay un tamaño de página, un valor predeterminado razonable y control sobre el uso de sus datos. Si el tamaño de página solicitado supera un valor máximo interno, y, luego, se usa el máximo interno.

Una lista de tareas puede incluir un token para leer la página siguiente de resultados. Usa el token de la página con una solicitud que sea idéntica a la anterior. para recuperar la página siguiente de tareas. Cuándo se devuelve el token de la página está vacío, no hay más tareas disponibles para recuperar.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para enumerar tareas para un deliveryVehicleId y un atributo de tarea. Se completó correctamente respuesta aún puede estar vacía. Si la respuesta está vacía, indica que no hay Tasks asociado al deliveryVehicleId suministrado.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TRACKING_ID = "TID-7449w087464x5";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
ListTasksRequest listTasksRequest = ListTasksRequest.newBuilder()  // No need for the header
    .setParent(parent)
    .setFilter("delivery_vehicle_id = 123 AND attributes.foo = true")
    .build();

try {
  ListTasksResponse listTasksResponse = deliveryService.listTasks(listTasksRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Para enumerar tareas de un navegador, realiza una llamada REST HTTP a ListTasks:

`GET https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks`

Para aplicar un filtro a las tareas de la lista, incluye un “filtro” Parámetro de URL con una búsqueda de filtro con escape de URL como su valor.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

Si la búsqueda se realiza correctamente, el cuerpo de la respuesta contendrá datos con la siguiente estructura:

    // JSON representation
    {
      "tasks": [
        {
          object (Task)
        }
      ],
      "nextPageToken": string,
      "totalSize": integer
    }

Una respuesta correcta aún puede estar vacía. Una respuesta vacía indica que no hay se encontraron tareas que cumplían con los criterios de filtro especificados.

Comando curl de ejemplo

    # Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
    curl -H "Authorization: Bearer ${JWT}" \
      "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?filter=state%20%3D%20OPEN%20AND%20delivery_vehicle_id%20%3D%20${VEHICLE_ID}"

Mostrar vehículos de entrega

Puedes enumerar vehículos de entrega desde un entorno de servidor o navegador. El conductor El SDK no admite la publicación de fichas de vehículos de entrega.

Enumerar los vehículos de entrega solicita un acceso amplio a los vehículos de entrega y es destinados únicamente a usuarios de confianza. Usa Delivery Fleet Reader o Delivery Super Usa tokens de autenticación de usuarios cuando realices solicitudes de listas de vehículos de entrega.

Los siguientes campos de los vehículos de entrega enumerados tienen los siguientes campos ocultos debido a su impacto según el tamaño de la respuesta:

• CurrentRouteSegment
• RemainingVehicleJourneySegments

Puedes filtrar la lista de vehículos de entrega por su propiedad de attributes. Para Por ejemplo, para consultar un atributo con la clave my_key y el valor my_value, usa attributes.my_key = my_value Para consultar varios atributos, une las consultas con los operadores lógicos AND y OR, como en attributes.key1 = value1 AND attributes.key2 = value2. Consulta AIP-160 para obtener una descripción de la sintaxis de consulta de filtro.

Puedes filtrar los vehículos de entrega de la lista por ubicación con la solicitud viewport parámetro. El parámetro de solicitud viewport define viewports con dos límites coordenadas: una latitud y longitud high (nordeste) y low (sudoeste) par de coordenadas. Las solicitudes se rechazan si contienen una latitud alta geográficamente más baja que una latitud baja.

Las listas de vehículos de entrega se paginan de forma predeterminada con un tamaño de página razonable. Si especificas un tamaño de página, la solicitud devuelve solo el número de vehículos especificado por el límite, o menos. Si el tamaño de página solicitado supera un límite se usa el valor máximo interno. Página predeterminada y máxima ambos tamaños son de 100 vehículos.

Una lista de vehículos de entrega puede incluir un token para leer la siguiente página de resultados. Un token de página solo está presente en una respuesta cuando hay más páginas de entrega vehículos están disponibles para su recuperación. Para recuperar la página siguiente de tareas, usa el token de la página con una solicitud que es idéntica a la anterior para cada solicitud.

gRPC

En el siguiente ejemplo, se muestra cómo usar la Biblioteca gRPC de Java para incluir vehículos de entrega en una región específica con un atributo específico. R respuesta correcta aún puede estar vacía. Cuando eso sucede, significa que Los vehículos con el atributo especificado ya están en el viewport especificado.

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

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
ListDeliveryVehiclesRequest listDeliveryVehiclesRequest =
  ListDeliveryVehiclesRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setViewport(
            Viewport.newBuilder()
              .setHigh(LatLng.newBuilder()
                  .setLatitude(37.45)
                  .setLongitude(-122.06)
                  .build())
              .setLow(LatLng.newBuilder()
                  .setLatitude(37.41)
                  .setLongitude(-122.11)
                  .build())
      .setFilter("attributes.my_key = my_value")
      .build();

try {
  ListDeliveryVehiclesResponse listDeliveryVehiclesResponse =
      deliveryService.listDeliveryVehicles(listDeliveryVehiclesRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
      case NOT_FOUND:
          break;

      case PERMISSION_DENIED:
          break;
  }
  return;
}

REST

Para enumerar tareas de un navegador, realiza una llamada REST HTTP a ListDeliveryVehicles:

`GET https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles`

Para aplicar un filtro a las tareas de la lista, incluye un “filtro” Parámetro de URL con un Es la consulta de filtro con escape de URL como su valor.

El encabezado de la solicitud debe contener un campo Authorization con el valor Bearer <token>, donde <token> es un token emitido por una fábrica de tokens de Fleet Engine.

Si la búsqueda se realiza correctamente, el cuerpo de la respuesta contendrá datos con la siguiente estructura:

// JSON representation
{
  "deliveryVehicles": [
    {
      object (DeliveryVehicle)
    }
  ],
  "nextPageToken": string,
  "totalSize": integer
}

Una respuesta correcta aún puede estar vacía. Cuando eso sucede, significa que Se encontraron vehículos de entrega que cumplían con la consulta de filtro y el viewport especificados.

Comando curl de ejemplo

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?filter=attributes.my_key%20%3D%20my_value%20&viewport.high.latitude=37.45&viewport.high.longitude=-122.06&viewport.low.latitude=37.41&viewport.low.longitude=-122.11"

Seguimiento de envíos

Tienes dos opciones para usar la API de Fleet Engine Deliveries para habilitar el seguimiento de envíos:

• Preferido: Usa el Biblioteca de JavaScript Shipment Tracking. La biblioteca te permite visualizar la ubicación de vehículos y ubicaciones de interés registrado en Fleet Engine. Contiene un componente de mapa de JavaScript que es un reemplazo directo de un objeto google.maps.Map estándar, y los componentes de datos para conectarse con Fleet Engine. Este componente te permite Proporcionan una experiencia de seguimiento de envíos animada y personalizable. desde tu aplicación web o para dispositivos móviles.

• Implementa tu propio seguimiento de envíos sobre la API de Fleet Engine Deliveries.

La clave es buscar las tareas de envío por ID de seguimiento.

Si usas un rol de consumidor de entrega, cualquier llamada a la API de Fleet Engine Deliveries devolver solo información relevante para un transportista o un receptor; Todos los demás información de las respuestas. Eres responsable para autenticar usuarios finales. Además, la información de ubicación se filtra en función de la tarea que ya está realizada. Durante una tarea de falta de disponibilidad, no se comparte información de ubicación con un usuario final.

Logging

Puedes configurar Fleet Engine para enviar registros de RPC a Cloud Logging. Para ver más información, consulta Registro.

Roles y tokens de autorización

Como se describe en Cómo administrar el ciclo de vida del vehículo y de las tareas y las notas de autorización para casos de uso individuales, lo que facilita llamadas a Fleet Engine requiere autenticación con tokens web JSON que tengan con credenciales de cuenta de servicio. Las cuentas de servicio que se usan para emitir esos tokens, pueden tener uno o más roles, y cada rol otorga un conjunto diferente de permisos.

Para obtener más información, consulta Autenticación y autorización.

Soluciona los problemas comunes

Consulta las siguientes secciones para obtener ayuda si tienes algún problema.

Resiliencia

Fleet Engine no se considera una fuente de información. Eres responsable para restablecer el estado de tu sistema, si es necesario, sin depender de Fleet Engine.

Estado perdido en Fleet Engine

Cuando trabajes con Fleet Engine, implementar clientes para que el sistema se corrija a sí mismo si hay una falla. Por ejemplo, cuando Fleet Engine intente actualizar un vehículo, es posible que responda con un error que indique que el vehículo no existen. Luego, el cliente debe recrear el vehículo en el estado nuevo. Si bien este problema con poca frecuencia, asegúrate de que tu sistema sea lo suficientemente resiliente que la modifica.

En la situación muy improbable de una falla catastrófica de Fleet Engine, es posible que debas recrear la mayoría o todos los vehículos y tareas. Si la tasa de creación es demasiado alto, algunas solicitudes pueden volver a fallar debido a problemas de cuota se realizan verificaciones de cuotas para evitar ataques de denegación del servicio (DoS). En este caso, reduce la velocidad de recreación con una estrategia de retirada intentos reiterados.

Estado perdido en la app del conductor

Si falla la app del conductor, debe volver a crear el estado actual. en el SDK de Driver. La app debe intentar recrear las tareas para garantizar que existen y restaurar sus estados actuales. La app también debe vuelve a crear y establece de forma explícita la lista de paradas para el SDK del controlador.

Preguntas frecuentes

¿Qué sucede si un conductor se detiene a realizar una tarea desordenada?

En este caso, primero actualiza el orden de las tareas y, luego, continúa como de costumbre. que marcan la llegada a la parada, la finalización de la tarea y otros detalles. Si no lo haces, el sistema podría incoherer y los ETA podrían ser incorrectos y se pueden informar errores inesperados.