เริ่มต้นใช้งาน Fleet Engine สำหรับการติดตามการจัดส่ง

สร้างแบบจำลองกิจกรรมกลุ่มอุปกรณ์ของคุณสำหรับระยะทางแรกและสุดท้ายในการจัดส่งด้วย Fleet Engine Deliveries API คุณสามารถใช้ API นี้โดยใช้ Driver SDK สำหรับ Android และ iOS หรือโดยตรงโดยใช้การเรียก HTTP REST หรือ gRPC

การตั้งค่าเบื้องต้น

คุณกำหนดค่า Fleet Engine Deliveries API ใน Google Cloud Console

• สำหรับข้อมูลเกี่ยวกับขั้นตอนที่ต้องดำเนินการภายในคอนโซลและวิธีสร้าง JSON Web Token สำหรับการให้สิทธิ์ โปรดดู การตรวจสอบสิทธิ์และการให้สิทธิ์

• ดูรายละเอียดเกี่ยวกับการใช้คอนโซลที่ เอกสารประกอบเกี่ยวกับ Google Cloud Console

ตรวจสอบการตั้งค่า

หลังจากสร้างบัญชีบริการแล้ว ให้ยืนยันว่าการตั้งค่าเสร็จสมบูรณ์แล้ว และสร้างยานพาหนะ สำหรับส่งสินค้าได้ กำลังยืนยันการตั้งค่าทันที จะแน่ใจว่าคุณได้แก้ไขปัญหาการให้สิทธิ์ทั่วไปที่อาจเกิดขึ้นเมื่อ กำลังตั้งค่าโปรเจ็กต์ ซึ่งการยืนยันการตั้งค่าทำได้ 2 วิธีดังนี้

• ทดสอบ 2 ส่วนสำคัญในการตั้งค่าของคุณ ได้แก่ การลงชื่อโทเค็นการให้สิทธิ์และการนำส่งการทดลองใช้ การสร้างยานพาหนะด้วย ยูทิลิตีบรรทัดคำสั่ง gcloud สำหรับ โปรดดูรายละเอียดที่หัวข้อการยืนยันการตั้งค่า

• ทดสอบการตั้งค่าด้วย สคริปต์ตัวอย่างการตรวจสอบสิทธิ์ของ Fleet Engine

ไลบรารีไคลเอ็นต์

เพื่อประสบการณ์ที่ดียิ่งขึ้นสำหรับนักพัฒนาซอฟต์แวร์มากกว่า gRPC หรือ REST แบบ RAW โปรดใช้ ไลบรารีของไคลเอ็นต์ในภาษาโปรแกรมทั่วไปหลายภาษา สำหรับ คำแนะนำเกี่ยวกับวิธีรับไลบรารีของไคลเอ็นต์สำหรับแอปพลิเคชันเซิร์ฟเวอร์ของคุณ โปรดดู ไลบรารีไคลเอ็นต์

ตัวอย่าง Java ในเอกสารประกอบนี้จะถือว่าคุณคุ้นเคยกับ gRPC อยู่แล้ว

โครงสร้างข้อมูล

Fleet Engine Deliveries API ใช้โครงสร้างข้อมูล 2 แบบในการสร้างโมเดลการมารับสินค้าและการจัดส่ง ของการจัดส่ง:

• รถนำส่งที่ใช้ลำเลียงสินค้า
• งานรับและจัดส่งพัสดุ

คุณยังใช้งานงานเพื่อสร้างแบบจำลองการหยุดพักคนขับรถและจุดแวะพักตามกำหนดการได้ด้วย ตลอดทั้งวัน

รถส่งของ

รถส่งของจะขนส่งสินค้าจากคลังสินค้าไปยังสถานที่นำส่ง และจากจุดรับไปยังคลังสินค้า ในบางกรณี อาจมีการดำเนินการดังนี้ ขนส่งการจัดส่งโดยตรงจากสถานที่รับพัสดุไปยังสถานที่นำส่ง

ใช้ Driver SDK เพื่อสร้างออบเจ็กต์ DeliveryVehicle ใน Fleet Engine และส่งการอัปเดตตำแหน่งสำหรับการจัดส่งและการติดตามยานพาหนะ

งาน

สำหรับการดำเนินการต่างๆ ของยานพาหนะในระหว่างวัน คุณจะมอบหมายงานตาม ประเภทการทำงาน

• สำหรับการรับสินค้าและการนำส่ง ให้มอบหมายงานการจัดส่ง
• สำหรับเวลาที่คนขับมาไม่ว่าง เช่น ต้องพักเบรก มอบหมายงานที่ไม่พร้อมใช้งาน
• สำหรับงานที่ไม่มีการขับรถที่ตู้ส่งสินค้าหรือตำแหน่งของลูกค้า ให้มอบหมาย งานที่กําหนดเวลาไว้

แต่ละงานที่คุณมอบหมายต้องมีรหัสงานที่ไม่ซ้ำกัน แต่งานเหล่านั้นจะใช้รหัสเดียวกันได้ รหัสติดตาม เมื่อ Fleet Engine คำนวณเวลาถึงโดยประมาณ สำหรับแต่ละงาน จะใช้งานทั้งหมด และลำดับ พวกเขาจะมีกำหนดการ ในการประมาณค่า ดูข้อมูลเพิ่มเติมเกี่ยวกับรหัสงานได้ที่ หลักเกณฑ์เกี่ยวกับรหัสงาน

หากต้องการสร้างงานใน Fleet Engine ให้ใช้ Driver SDK Task Manager

งานการจัดส่ง

สร้างงานการจัดส่งสำหรับทั้งการรับสินค้าและการจัดส่ง และ มีข้อมูลต่อไปนี้

• สถานที่รับสินค้าหรือจัดส่ง
• หมายเลขหรือรหัสติดตาม
• เวลาที่ไม่มีการขยับเมาส์เพื่อเผื่อเวลาเพิ่มเติมในการทำงานให้เสร็จสมบูรณ์ ดู เพื่อหาที่จอดรถ หรือเดินไปที่จุดส่งมอบ
• รหัสงานที่ไม่ซ้ำกัน ดูหลักเกณฑ์เกี่ยวกับรหัสงาน

สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อต่อไปนี้

Android

• สร้างงานรับสินค้าสำหรับการจัดส่ง
• สร้างงานการนำส่งการจัดส่ง

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

งานที่ไม่พร้อมใช้งาน

งานที่ไม่พร้อมใช้งานจะครอบคลุมระยะเวลาที่รถยนต์ไม่พร้อมใช้งาน การรับสินค้าหรือการนำส่ง เช่น ช่วงพักเพื่อเติมน้ำมันรถหรือคนขับ การหยุดพัก

สร้างงานที่ไม่พร้อมใช้งานด้วยข้อมูลต่อไปนี้

• ระยะเวลาของช่วงพัก
• (ไม่บังคับ) ตำแหน่งของช่วงพัก คุณไม่จำเป็นต้องระบุ ตำแหน่งที่เจาะจง แต่การทำเช่นนั้นจะทำให้กรอบเวลา ETA มีความแม่นยำมากขึ้น ตลอดทั้งวัน

สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อต่อไปนี้

Android

• ความไม่พร้อมให้บริการตามกำหนดเวลา

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

งานที่กําหนดเวลาไว้

สร้างงานการหยุดที่กำหนดเวลาไว้เพื่อสร้างแบบจำลองจุดแวะพักที่รถส่งของต้องการ ในแบบที่จะทำ เช่น สร้างงานที่กำหนดให้หยุดไว้สำหรับการกำหนดเวลาประจำวัน ไปรับที่ตำแหน่งใดตำแหน่งหนึ่งโดยไม่ขึ้นอยู่กับการจัดส่งอื่นๆ หรือไปรับเองที่จุดเดียวกัน คุณยังสร้างงานที่ต้องการให้หยุดไว้ได้ด้วย สำหรับคอลเล็กชันจากกล่องรับสัญญาณหรือโมเดลรถป้อนกระดาษ หรือหยุดที่ศูนย์บริการและจุดบริการ

สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อต่อไปนี้

Android

• แวะพักตามกำหนดการ

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

หลักเกณฑ์เกี่ยวกับรหัสงาน

เมื่อสร้างรหัสงาน ให้ทำตามหลักเกณฑ์เกี่ยวกับเนื้อหาและรูปแบบต่อไปนี้

• สร้างรหัสงานที่ไม่ซ้ำกัน
• อย่าเปิดเผยข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) หรือ ล้างข้อมูลข้อความ
• ใช้สตริง Unicode ที่ถูกต้อง
• ใช้อักขระไม่เกิน 64 ตัว
• อย่าใส่อักขระ ASCII ใดๆ ต่อไปนี้: "/", ":", "\", "?" หรือ "#"
• ทำให้เป็นมาตรฐานตามแบบฟอร์มการปรับมาตรฐานรหัส C ของ Unicode

ตัวอย่างของรหัสงานที่ดีมีดังต่อไปนี้

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

ตารางต่อไปนี้แสดงตัวอย่างรหัสงานที่ไม่รองรับ

รหัสงานที่ไม่รองรับ	เหตุผล
8/31/2019-20:48-46.70746,-130.10807,-85.17909,61.33680	ละเมิดข้อกำหนดด้าน PII และอักขระ เช่น คอมมา จุด โคลอน และเครื่องหมายทับ
JohnDoe-577b484da26f-Cupertino-SantaCruz	ละเมิดข้อกำหนดเกี่ยวกับ PII
4R0oXLToF"112 ฤดูร้อน ดร. อีสต์ฮาร์ตฟอร์ด, CT06118"577b484da26f8a	ละเมิดข้อกำหนดด้าน PII และอักขระ เช่น ช่องว่าง คอมมา และเครื่องหมายคำพูด ยาวกว่า 64 อักขระ

แหล่งข้อมูลเพิ่มเติม

วิธีดูช่องที่เจาะจงซึ่งมีอยู่ในข้อมูลแต่ละรายการ โปรดดูเอกสารอ้างอิง API สำหรับ DeliveryVehicle (gRPC, REST) และ Task (gRPC, REST)

อายุการใช้งานของยานพาหนะ

ออบเจ็กต์ DeliveryVehicle แสดงยานพาหนะที่นำส่งไมล์แรกหรือสุดท้าย คุณสร้างออบเจ็กต์ DeliveryVehicle โดยใช้สิ่งต่อไปนี้

• รหัสของโปรเจ็กต์ Google Cloud ที่มีบัญชีบริการ ที่ใช้เรียก Fleet Engine API
• รหัสยานพาหนะที่ลูกค้าเป็นเจ้าของ

ใช้รหัสยานพาหนะที่ไม่ซ้ำกันสำหรับยานพาหนะแต่ละคัน อย่าใช้รหัสยานพาหนะซ้ำ เว้นแต่จะไม่มีงานที่ทำอยู่สำหรับยานพาหนะเดิม

Fleet Engine จะลบออบเจ็กต์ DeliveryVehicle รายการโดยอัตโนมัติที่ไม่ ได้รับการอัปเดตด้วย UpdateDeliveryVehicle หลังจาก 7 วัน คำแนะนำ แนวทางที่จะทำให้ยานพาหนะอยู่ใน Fleet Engine อยู่เสมอคือการอัปเดตตำแหน่ง อย่างสม่ำเสมอ การอัปเดตช่องอื่นๆ ส่วนใหญ่ใน DeliveryVehicle เอนทิตีจะยืดระยะเวลาออกไปด้วย หากค่าฟิลด์ใหม่ไม่เท่ากัน จากที่มีอยู่

วิธีดูว่ามียานพาหนะอยู่หรือไม่

1. โทรหา UpdateDeliveryVehicle
2. หากคุณได้รับข้อผิดพลาด NOT_FOUND โปรดโทรไปที่ CreateDeliveryVehicle เพื่อสร้างยานพาหนะใหม่ หากมีการส่งคืนรถยนต์ คุณก็จะยังคงอัปเดตได้

ประเภทยานพาหนะ

เอนทิตี VehicleType มีช่องที่ไม่บังคับของ VehicleType ซึ่งมีเอลิเมนต์ enum ของ Category ที่คุณสามารถระบุเป็น AUTO, TWO_WHEELER, BICYCLE หรือ PEDESTRIAN หากไม่ได้ตั้งค่าฟิลด์นี้ ค่าเริ่มต้นจะเป็น AUTO

เส้นทางทั้งหมดสำหรับยานพาหนะใช้ RouteTravelMode ที่สอดคล้องกัน สำหรับประเภทยานพาหนะ

แอตทริบิวต์ของยานพาหนะ

เอนทิตี DeliveryVehicle มีช่องที่ซ้ำของ DeliveryVehicleAttribute ListDeliveryVehicles API มี filter ซึ่งสามารถจำกัดเอนทิตี DeliveryVehicle ที่แสดงผลไว้เฉพาะรายการที่มี แอตทริบิวต์ที่ระบุ DeliveryVehicleAttribute ไม่ส่งผลกระทบต่อ Fleet Engine ลักษณะการทำงานของการกำหนดเส้นทาง

อย่าใส่ข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) หรือข้อมูลที่ละเอียดอ่อน ในแอตทริบิวต์ เนื่องจากฟิลด์นี้อาจปรากฏแก่ผู้ใช้

ชีวิตในการทำงาน

คุณสร้าง อัปเดต และค้นหางานใน Fleet Engine ได้ด้วย อินเทอร์เฟซ gRPC หรือ REST ของ Deliveries API

ออบเจ็กต์ Task มีช่องสถานะเพื่อติดตามความคืบหน้า ตลอดอายุการใช้งาน ค่าจะย้ายจาก OPEN ไปยัง CLOSED สร้างงานใหม่แล้ว ในสถานะ OPEN ซึ่งระบุว่า:

• ยังไม่มีการมอบหมายงานให้กับยานพาหนะที่นำส่งสินค้า
• ยานพาหนะที่นำส่งยังไม่ผ่านป้ายจอดรถที่ได้รับมอบหมายของงาน

หลักเกณฑ์ของงาน

คุณจะมอบหมายงานให้กับยานพาหนะได้เมื่ออยู่ในสถานะ "เปิด" เท่านั้น

คุณสามารถยกเลิกงานโดยนำงานออกจากรายการจุดแวะพักของยานพาหนะ ซึ่งจะตั้งค่า สถานะงานเป็น "ปิด" โดยอัตโนมัติ

เมื่อยานพาหนะของงานเสร็จสมบูรณ์

1. อัปเดตช่องผลลัพธ์ของงานเป็น "SUCCEEDED" หรือ "ล้มเหลว"

2. ระบุการประทับเวลาของเหตุการณ์

   จากนั้นไลบรารีการติดตามการจัดส่ง JavaScript จะแสดงผลลัพธ์ของงานและ สถานะของงานจะเป็น "ปิด" โดยอัตโนมัติ สำหรับข้อมูลเพิ่มเติม โปรดดู ติดตามการจัดส่งด้วยไลบรารีการติดตามการจัดส่งของ JavaScript

เช่นเดียวกับยานพาหนะ Fleet Engine จะลบงานที่ยังไม่ได้อัปเดตหลังจาก 7 วัน และหากคุณพยายามสร้างงานด้วยรหัสที่มีอยู่แล้ว ข้อผิดพลาดจะแสดงขึ้นมา

หมายเหตุ: Fleet Engine ไม่รองรับการลบงานอย่างชัดแจ้ง บริการ ลบงานโดยอัตโนมัติหากไม่มีการอัปเดตเป็นเวลา 7 วัน หากต้องการเก็บรักษาข้อมูลงานไว้นานกว่า 7 วัน คุณต้องใช้ความสามารถนั้นด้วยตัวเอง

แอตทริบิวต์ของงาน

เอนทิตี Task มีช่องที่ซ้ำของ TaskAttribute ซึ่งจะมีค่าจาก 3 ประเภท ซึ่งได้แก่ สตริง ตัวเลข และบูลีน ListTasks API มีช่อง filter ที่จำกัดการแสดงผลได้ Task เป็นเอนทิตีที่มีแอตทริบิวต์ที่ระบุ แอตทริบิวต์งานไม่ ส่งผลต่อลักษณะการทำงานของการกำหนดเส้นทาง Fleet Engine

อย่าใส่ข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) หรือข้อมูลที่ละเอียดอ่อนอื่นๆ ในแอตทริบิวต์ต่างๆ เนื่องจากผู้ใช้อาจเห็นแอตทริบิวต์เหล่านี้ได้

จัดการรถและวงจรงาน

โปรดทราบ: ระบบภายในของคุณทำหน้าที่เป็นแหล่งข้อมูลที่เชื่อถือได้ซึ่ง Fleet Engine Deliveries API เสริมแต่งในนามของคุณ

หากต้องการจัดการอายุการใช้งานของยานพาหนะและงานในระบบ ให้ใช้ Fleet Engine Deliveries API เพื่อสร้าง อัปเดต และติดตามยานพาหนะของคุณ รวมถึงงานที่เกี่ยวข้อง

ในขณะเดียวกัน แอปพลิเคชันไดรเวอร์ก็สื่อสารกับ Fleet Engine โดยตรง เพื่ออัปเดตตำแหน่งอุปกรณ์และข้อมูลเส้นทาง โมเดลนี้ช่วยให้ Fleet Engine จัดการตำแหน่งแบบเรียลไทม์ได้อย่างมีประสิทธิภาพ ซึ่งจะส่งสถานที่ตั้งไปยัง ไลบรารีการติดตาม ซึ่งคุณสามารถใช้เพื่ออัปเดตสถานะของผู้บริโภค ของคำสั่งซื้อนั้นๆ

ตัวอย่างเช่น สมมติว่าคุณมีสถานการณ์ต่อไปนี้

• คนขับอยู่ใกล้กับจุดส่งสินค้า แอปพลิเคชันไดรเวอร์จะส่งตำแหน่งไปที่ Fleet Engine
• Fleet Engine ส่งตำแหน่งอุปกรณ์ไปยัง ไลบรารีการติดตาม ซึ่งแอปพลิเคชันของผู้บริโภคของคุณใช้เพื่อแจ้งเตือนผู้บริโภค กับความใกล้ของพัสดุ
• หลังจากคนขับรถส่งสินค้าให้แล้ว ก็คลิกข้อความ "จัดส่งแล้ว" บนแอปพลิเคชันไดรเวอร์
• คอลัมน์ "การจัดส่งที่นำส่งแล้ว" จะส่งข้อมูลไปยังระบบแบ็กเอนด์ ซึ่งทำการตรวจสอบธุรกิจและขั้นตอนการยืนยันที่จำเป็น
• ระบบของคุณยืนยันงานเป็น SUCCEEDED และอัปเดต Fleet Engine โดยใช้ API การนำส่ง

แผนภาพต่อไปนี้แสดงขั้นตอนเหล่านี้ในระดับทั่วไป และ แสดงความสัมพันธ์มาตรฐานระหว่างระบบของคุณ ไคลเอ็นต์ และ Fleet Engine

จัดการโทเค็นของไคลเอ็นต์

การอัปเดตตำแหน่งที่มาจากแอปพลิเคชันไดรเวอร์และส่งโดยตรง ไปยัง Fleet Engine ต้องมีโทเค็นการให้สิทธิ์ แนวทางที่แนะนำมีดังนี้ จัดการการอัปเดตจากไคลเอ็นต์ไปยัง Fleet Engine โดยทำดังนี้

1. สร้างโทเค็นโดยใช้ผู้ใช้ไดรเวอร์ที่ไม่น่าเชื่อถือของ Fleet Engine Delivery บทบาทบัญชีบริการ

2. ระบุโทเค็นที่มีขอบเขตจำกัดให้กับแอปพลิเคชันไดรเวอร์ ขอบเขตนี้ อนุญาตให้อัปเดตตำแหน่งอุปกรณ์ใน Fleet Engine เท่านั้น

วิธีนี้ทำให้แน่ใจได้ว่าการโทรที่มาจากอุปกรณ์เคลื่อนที่ สภาพแวดล้อมที่มีความน่าเชื่อถือต่ำ - ปฏิบัติตาม หลักการให้สิทธิ์ขั้นต่ำที่สุด

บทบาทอื่นๆ ของบัญชีบริการ

แต่หากคุณต้องการอนุญาตแอปพลิเคชันไดรเวอร์เพื่อกำหนด การอัปเดต Fleet Engine นอกเหนือจากการอัปเดตที่จำกัดเฉพาะบทบาทคนขับที่ไม่น่าเชื่อถือ เช่น สำหรับการอัปเดตงานบางอย่าง คุณสามารถใช้บทบาทไดรเวอร์ที่เชื่อถือได้ สำหรับ ข้อมูลเกี่ยวกับโมเดลที่ใช้บทบาทไดรเวอร์ที่เชื่อถือได้ โปรดดู รุ่นไดรเวอร์ที่เชื่อถือได้

ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้บทบาทไดรเวอร์ที่ไม่น่าเชื่อถือและเชื่อถือได้ที่ การตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์

จำลองวันทำงาน

ตารางต่อไปนี้อธิบายวิธีการทำงานของผู้ขับขี่ระยะแรกหรือระยะสุดท้ายที่วิ่งได้ อาจดูในบริษัทจัดส่งและโลจิสติกส์ บริษัทของคุณอาจ มีรายละเอียดต่างกัน แต่คุณสามารถดูรูปแบบ วันทำงานของคุณได้

เวลา	กิจกรรม	การสร้างแบบจำลอง
ภายใน 24 ชั่วโมงหลังจากเริ่มต้นวัน	พนักงานมอบหมายการจัดส่งให้กับยานพาหนะหรือเส้นทางส่งของ	คุณสามารถสร้างงานสำหรับการนำส่งพัสดุ รับสินค้า การหยุดพัก และ คนอื่นๆ ใน Fleet Engine ล่วงหน้า ตัวอย่างเช่น คุณสามารถสร้าง งานการรับสินค้า งานด้านการนำส่งสินค้า ไม่พร้อมให้บริการตามกำหนดเวลา หรือ จุดแวะพักที่ตั้งเวลาไว้ มอบหมายงานให้กับยานพาหนะหลังจากชุดแพ็กเกจการนำส่งแล้ว และลำดับที่ควรส่งนั้นได้รับการสรุปแล้ว
เมื่อเริ่มต้นวัน	คนขับเริ่มต้นวันใหม่ที่คลังสินค้าโดยเข้าสู่ระบบแอปคนขับ	เริ่มต้น Delivery Driver API สร้างยานพาหนะสำหรับนำส่งใน Fleet Engine ตามความจำเป็น
	คนขับบรรทุกสินค้าลงจอดบนรถนำส่ง โดยสแกนการจัดส่ง	หากไม่ได้สร้างงานจัดส่งก่อนเวลา สร้างงานจัดส่งพัสดุ ณ เวลาที่สแกน
	คนขับยืนยันลำดับงานที่ต้องทำ	หากไม่ได้สร้างโฆษณาไว้ก่อน ให้สร้าง งานรับสินค้าที่จัดส่ง ความไม่พร้อมใช้งานตามกำหนดเวลา และ จุดแวะพักตามกำหนดการ
	คนขับออกจากสถานีและตกลงกันว่าจะมีงานทำต่อไป เสร็จสมบูรณ์แล้ว	มอบหมายงานทั้งหมดหรือชุดย่อยของงาน โดยดำเนินการตามคำสั่งซ่อม
	คนขับจัดส่งสินค้า	หลังจากมาถึงจุดนำส่งแล้ว ให้ดำเนินการต่างๆ ที่เกี่ยวข้อง ไปยังยานพาหนะที่มาถึงจุดแวะพัก หลังจากนำส่งสินค้าที่นำส่งแล้ว ให้ปิดคำสั่งซื้อ งานที่ส่ง และหากต้องการ เก็บสถานะการจัดส่งและข้อมูลเมตาอื่นๆ หลังจากเสร็จงานทั้งหมด ณ ป้ายจอดรถและก่อน เริ่มขับไปยังจุดแวะพักถัดไป ดำเนินการต่างๆ ที่เกี่ยวข้องกับ พาหนะจอด และพาหนะกำลังเดินทางไปยังจุดแวะพักถัดไป
	คนขับมาพบกับยานพาหนะที่ให้อาหารเพื่อถ่ายโอนการจัดส่งเพิ่มเติมไปยังรถนำส่ง	จุดนัดพบสำหรับการเปลี่ยนยานพาหนะระหว่างฟีดเดอร์และยานพาหนะนำส่ง ควรประมาณเป็นการหยุดที่กำหนดไว้ หลังจากโอนและสแกนการจัดส่งแล้ว ให้สร้างงานการนำส่ง หากยังไม่ได้สร้างขึ้น จากนั้นอัปเดตงานที่ทำเสร็จแล้ว สั่งอาหารโดยมอบหมายงานให้ยานพาหนะ และอัปเดตลำดับงาน
	คนขับได้รับการแจ้งเตือนเกี่ยวกับคำขอให้ไปรับสินค้า	หลังจากยอมรับคำขอรับสินค้าแล้ว สร้างงานรับสินค้าสำหรับการจัดส่ง จากนั้นอัปเดตการดำเนินการของงาน สั่งอาหารโดยมอบหมายงานให้ยานพาหนะ และอัปเดตลำดับงาน
เที่ยงวัน	คนขับรถพักกลางวัน	หากสถานที่เชื่อมโยงกับงานที่ไม่พร้อมให้บริการ ให้ทำดังต่อไปนี้ งานอื่นๆ ดำเนินการที่เกี่ยวข้องกับยานพาหนะ มาถึงจุดแวะ รถจอดเรียบร้อย และพาหนะขับอยู่ระหว่างทางไปยังจุดหมายถัดไป ไม่เช่นนั้น ก็ไม่จำเป็นต้องดำเนินการใดๆ เพิ่มเติมจนกว่าจะสิ้นสุดช่วงพัก นำงานออกโดยยืนยันงานถัดไปและงานที่เหลืออยู่ และ อัปเดตลำดับงาน
	คนขับไปรับพัสดุ	ซึ่งระบบจำลองนี้เหมือนกับจุดแวะแสดงโฆษณา ดำเนินการที่เกี่ยวข้อง ไปยังยานพาหนะที่มาถึงจุดแวะ และการปิดงาน และ (ไม่บังคับ) การจัดเก็บสถานะการจัดส่งและข้อมูลเมตาอื่นๆ หลังจากทำงานทั้งหมดที่ป้ายจอดรถและก่อนเริ่มขับรถ ที่จุดแวะถัดไป ให้ดําเนินการที่เกี่ยวข้องกับยานพาหนะจอดเสร็จแล้ว และพาหนะกำลังเดินทางไปยังจุดแวะพักถัดไป หมายเหตุ: เพื่อให้การเรียกเก็บเงินถูกต้อง การรับสินค้าทั้งหมดต้องมีแอตทริบิวต์ งานที่ส่ง หากจะให้ลูกค้านำของไปส่งที่อื่นใน เส้นทางเดิมของผู้ขับขี่ในวันนั้น เราขอแนะนำให้ ประมาณงานที่ส่ง งานนำส่งอื่นๆ ในเส้นทาง หากคนขับนำสินค้ามารับ กลับไปยังสถานีขนส่ง เราขอแนะนำให้สร้างงานส่งที่คลังสินค้า ปลายทาง
	คนขับได้นัดหมายเวลาเพื่อรับพัสดุจากกล่องส่งของ	โมเดลนี้จำลองมาเช่นเดียวกับจุดรับของอื่นๆ ดำเนินการที่เกี่ยวข้อง ไปยังยานพาหนะที่มาถึงจุดแวะ และการปิดงาน หลังจากเสร็จสิ้น งานทั้งหมดที่ป้ายหยุด และเริ่มขับไปยังป้ายหยุดถัดไป ดำเนินการที่เกี่ยวข้องกับยานพาหนะหยุดพัก และพาหนะกำลังเดินทางไปยังจุดแวะพักถัดไป
	คนขับได้รับการแจ้งเตือนว่ามีการจัดส่งถูกเปลี่ยนเส้นทางไปยังสถานที่อื่น	ตั้งค่าสถานะงานการนำส่งการจัดส่งเดิมเป็น "เสร็จสมบูรณ์" และสร้าง งานการนำส่งการจัดส่งสำหรับสถานที่นำส่งใหม่ สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อเปลี่ยนเส้นทางการจัดส่ง
	คนขับพยายามนำส่งพัสดุ แต่ไม่สามารถทำได้	นี่เป็นการสร้างรูปแบบที่คล้ายกับการหยุดนำส่งที่ประสบความสำเร็จ ซึ่งทำเครื่องหมาย งานที่ส่งว่าเสร็จแล้ว ดำเนินการเกี่ยวกับ ยานพาหนะที่มาถึงจุดแวะพัก หลัง นำส่งพัสดุไม่สำเร็จ ปิดงาน และ (ไม่บังคับ) เก็บสถานะการจัดส่งและข้อมูลเมตาอื่นๆ หลังจากทำงานทั้งหมดที่ป้ายจอดรถและก่อนเริ่มขับรถ ที่จุดแวะถัดไป ให้ดําเนินการที่เกี่ยวข้องกับยานพาหนะจอดเสร็จแล้ว และพาหนะกำลังเดินทางไปยังจุดแวะพักถัดไป
	คนขับได้รับการแจ้งเตือนให้ระงับ (ไม่นำส่ง) พัสดุ	หลังจากที่ได้รับและยืนยันการแจ้งเตือนแล้ว ตั้งค่าสถานะงานเป็น "เสร็จสมบูรณ์"
	คนขับได้รับการแจ้งเตือนให้นำส่งพัสดุบางรายการเป็นลำดับถัดไป และเปลี่ยนคำสั่งซื้อการนำส่งที่คอมมิต	อัปเดตลำดับงาน
	คนขับเลือกนำส่งพัสดุที่ล่าช้า	อัปเดตลำดับงานแล้ว ดำเนินการตามปกติ
	คนขับส่งสินค้าหลายรายการไปยังสถานที่ตั้งแห่งเดียว	โมเดลนี้สร้างแบบจำลองคล้ายกับจุดแวะพักสำหรับนำส่งสินค้าแห่งเดียว หลังจากมาถึงที่ป้ายแล้ว ให้ดำเนินการตาม ยานพาหนะที่จอดมาถึงจุดแวะพัก หลังจากนำส่งแต่ละการจัดส่งแล้ว ให้ปิดแต่ละงาน และจัดเก็บสถานะการจัดส่งและข้อมูลเมตาอื่นๆ (ไม่บังคับ) หลังจากทำงานทั้งหมดที่ป้ายจอดรถและก่อนเริ่มขับรถ ที่จุดแวะถัดไป ให้ดําเนินการที่เกี่ยวข้องกับยานพาหนะจอดเสร็จแล้ว และพาหนะกำลังเดินทางไปยังจุดแวะพักถัดไป
เมื่อสิ้นสุดวัน	คนขับกลับไปที่สถานี	หากคนขับกลับไปที่สถานีขนส่งที่มีสิ่งที่ไปรับระหว่าง คุณต้องสร้างและปิดแต่ละแพ็กเกจให้เป็นงานนำส่ง เพื่อให้แน่ใจว่าการเรียกเก็บเงินถูกต้อง คุณสามารถทำได้โดยสร้างรูปแบบของ Depot จุดแวะจัดส่งอื่นๆ หากไม่ได้ใช้ร้านค้าเป็นจุดแวะพัก คุณยังคงสามารถเลือก สร้างแบบจำลองให้สถานีเป็นจุดแวะพักตามกำหนดการ การประมาณจุดแวะพักช่วยให้ผู้ขับขี่เห็น เส้นทางกลับไปยังสถานีขนส่งและเปิดเผยเวลาโดยประมาณ ถึง

วิธีการทำงานของการอัปเดตตำแหน่ง

ด้วยเครื่องยนต์ Fleet Engine เพื่อประสิทธิภาพที่ดีที่สุด การอัปเดตตำแหน่ง ใช้วิธีใดวิธีหนึ่งต่อไปนี้เพื่อแจ้งการอัปเดต

1. ใช้ Driver SDK - Android iOS -- ตัวเลือกที่ง่ายที่สุด
2. ใช้โค้ดที่กำหนดเอง -- มีประโยชน์หากสถานที่ ส่งต่อผ่านแบ็กเอนด์ของคุณ หรือหากคุณใช้อุปกรณ์อื่นที่ไม่ใช่ Android หรือ iOS

ไม่ว่าคุณจะอัปเดตตำแหน่งของรถด้วยวิธีใด แบ็กเอนด์ของคุณจะ มีหน้าที่อัปเดต Fleet Engine เมื่อยานพาหนะนำส่งสินค้า เปลี่ยนเส้นทางไปยังจุดแวะพัก (รวมถึงสถานีขนส่ง) และเมื่อ มาถึงจุดพัก Fleet Engine ตรวจไม่พบเหตุการณ์เหล่านี้ โดยอัตโนมัติ

จุดจอดยานพาหนะและสถานที่นำส่ง

จุดจอดยานพาหนะคือที่ที่ยานพาหนะนำส่งทำการจัดส่งสำเร็จ หรืองานอื่น เป็นจุดเข้าใช้งาน เช่น แท่นชาร์จ หรือ ตำแหน่งที่อยู่บนถนน

สถานที่นำส่งคือสถานที่นำส่งสินค้า หรือมีคนรับสาย การเดินทางไปและกลับจากสถานที่จัดส่งอาจต้องเดินเท้าบ้าง จากป้ายจอดรถ

เช่น เมื่อคนขับนำส่งสินค้าไปยังร้านค้าในห้างสรรพสินค้า รถส่งของจอดที่ลานจอดรถของห้างสรรพสินค้าใกล้กับ ทางเข้าร้านที่ใกล้ที่สุด นี่เป็นป้ายจอดรถ ผู้ขับขี่ แล้วเดินจากป้ายรถไปยังตำแหน่งภายในห้างสรรพสินค้าซึ่ง ร้านก็ตั้งอยู่ นี่คือสถานที่จัดส่ง

ลองพิจารณาวิธีต่อไปนี้ เพื่อประสบการณ์การติดตามการจัดส่งที่ดีที่สุดสำหรับผู้ใช้ จะมอบหมายงานการจัดส่งให้กับจุดแวะพักของยานพาหนะ และโปรดทราบว่าจำนวนครั้ง มีการรายงานจุดจอดยานพาหนะที่เหลืออยู่สำหรับงานจัดส่งไปยังผู้ใช้เพื่อให้ความช่วยเหลือ ดูความคืบหน้าของการจัดส่ง

เช่น หากคนขับรถส่งของจำนวนมากไปที่อาคารสำนักงานเดียว ลองมอบหมายงานการนำส่งทั้งหมดให้จุดแวะพักจุดเดียว ถ้า งานการนำส่งแต่ละงานจะมอบหมายให้กับจุดจอดยานพาหนะของตนเอง การจัดส่งของคุณ การติดตามไม่ค่อยมีประโยชน์ต่อผู้ใช้ เนื่องจากการติดตามนั้น ใช้ได้เมื่อยานพาหนะอยู่ภายในจำนวนป้ายจอดรถที่จำกัดก่อนวันที่ จุดหมาย การมีป้ายจอดรถจำนวนมากที่เสร็จภายในระยะเวลาอันสั้นไม่ได้ ผู้ใช้ต้องใช้เวลาอย่างมากในการติดตามความคืบหน้าของการนำส่ง

ใช้ SDK อุปกรณ์เคลื่อนที่

ก่อนเรียกใช้ Driver SDK โปรดเริ่มต้นการทำงานของ SDK นั้น

เริ่มต้น Delivery Driver API

ก่อนเริ่มต้นใช้งาน Delivery Driver API ใน Driver SDK โปรดตรวจสอบว่า เพื่อเริ่มต้น Navigation SDK จากนั้นเริ่มต้น Delivery Driver API ดังที่ปรากฏในตัวอย่างต่อไปนี้

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));
     }
   });

กรณีการใช้งาน

ส่วนนี้จะอธิบายวิธีใช้ Deliveries API เพื่อสร้างรูปแบบสำหรับกรณีการใช้งานทั่วไป

ตัวระบุเอนทิตีที่ไม่ซ้ำกัน

รูปแบบและค่าของตัวระบุเอนทิตีที่ไม่ซ้ำกันที่ใช้ในการเรียก REST ทึบแสงต่อ Fleet Engine หลีกเลี่ยงการใช้รหัสที่เพิ่มขึ้นอัตโนมัติ และตรวจสอบว่า ตัวระบุไม่มีข้อมูลส่วนบุคคลที่ระบุตัวบุคคลนั้นได้ (PII) เช่น หมายเลขโทรศัพท์ของคนขับ

สร้างพาหนะ

คุณจะสร้างพาหนะได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST

gRPC

หากต้องการสร้างยานพาหนะใหม่ โปรดโทรหา Fleet Engine ด้วย CreateDeliveryVehicle ใช้ออบเจ็กต์ CreateDeliveryVehicleRequest เพื่อกำหนดแอตทริบิวต์ของ ยานพาหนะใหม่ที่ใช้ส่งของ โปรดทราบว่าค่าใดๆ ที่ระบุสำหรับฟิลด์ Name จะ ละเว้นตามคำแนะนำ API สำหรับรหัสที่ผู้ใช้ระบุ คุณควรใช้ช่อง DeliveryVehicleId เพื่อตั้งค่ารหัสของยานพาหนะ

เมื่อสร้าง DeliveryVehicle คุณจะระบุช่องต่อไปนี้หรือไม่ก็ได้

• Attributes
• LastLocation
• ประเภท

อย่าตั้งค่าช่องอื่นๆ หากใส่ Fleet Engine จะแสดงข้อผิดพลาด เนื่องจากฟิลด์เหล่านั้นเป็นแบบอ่านอย่างเดียว หรืออัปเดตได้ด้วยการเรียกไปยัง UpdateDeliveryVehicle

หากต้องการสร้างยานพาหนะโดยไม่ตั้งค่าฟิลด์ที่ไม่บังคับ คุณสามารถออกจาก ยกเลิกการตั้งค่าช่อง DeliveryVehicle ใน CreateDeliveryVehicleRequest

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีสร้างยานพาหนะ

    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

หากต้องการสร้างยานพาหนะจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ถึง CreateDeliveryVehicle:

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

<id> คือตัวระบุที่ไม่ซ้ำกันสำหรับยานพาหนะที่นำส่งสินค้าของคุณในยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหา POST แสดงเอนทิตี DeliveryVehicle ที่จะสร้าง คุณสามารถระบุ ฟิลด์ที่ไม่บังคับต่อไปนี้

• แอตทริบิวต์
• lastLocation
• ประเภท

ตัวอย่างคำสั่ง curl

# 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 ไม่สนใจช่อง name ของเอนทิตี DeliveryVehicle ตามคำแนะนำของ API สำหรับรหัสที่ผู้ใช้ระบุ อย่าตั้งค่าช่องอื่นๆ หากใส่ Fleet Engine จะแสดงข้อผิดพลาด เนื่องจากฟิลด์เหล่านั้นเป็นแบบอ่านอย่างเดียว หรืออัปเดตได้โดยใช้การเรียก UpdateDeliveryVehicle

หากต้องการสร้างยานพาหนะโดยไม่ตั้งค่าช่องใดๆ ให้ออกจากเนื้อหาของ POST ไม่มีคำขอ ยานพาหนะที่สร้างขึ้นใหม่จะดึงข้อมูลรหัสยานพาหนะจาก deliveryVehicleId ใน URL ของ POST

ตัวอย่างคำสั่ง curl

# 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}"

สร้างงานรับสินค้าสำหรับการจัดส่ง

คุณสร้างงานรับสินค้าสำหรับการจัดส่งได้จาก SDK ของไดรเวอร์ หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีสร้างงานการรับสินค้า

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

หากต้องการสร้างงานรับสินค้าสำหรับการจัดส่งจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ถึง CreateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน ต้องไม่ใช่หมายเลขติดตาม สำหรับการจัดส่ง หากไม่มีรหัสงานในระบบ คุณอาจสร้าง ตัวระบุที่ไม่ซ้ำกันทั่วโลก (UUID)

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  ประเภท	Type.PICKUP
  รัฐ	State.OPEN
  trackingId	หมายเลขหรือตัวระบุที่คุณใช้ในการติดตามการจัดส่ง
  plannedLocation	ในกรณีนี้คือตำแหน่งที่งานจะเสร็จสิ้น สถานที่รับสินค้า
  taskDuration	เวลาที่คาดว่าจะใช้ในการรับสินค้า โดยมีหน่วยเป็นวินาที ณ จุดรับรถ

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  targetTimeWindow	กรอบเวลาที่งานควรเสร็จสิ้น การดำเนินการนี้จะไม่ ส่งผลต่อลักษณะการทำงานของการกำหนดเส้นทาง
  แอตทริบิวต์	รายการแอตทริบิวต์งานที่กำหนดเอง แอตทริบิวต์แต่ละรายการต้องมีคีย์ที่ไม่ซ้ำกัน

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine ขว้าง ข้อยกเว้นหากคำขอมี deliveryVehicleId ที่มอบหมาย คุณมอบหมาย งานโดยใช้ UpdateDeliveryVehicleRequest สำหรับข้อมูลเพิ่มเติม โปรดดู มอบหมายงานให้ยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง curl

# 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

สร้างงานการนำส่งการจัดส่ง

สร้างงานการนำส่งการจัดส่งจาก SDK ของไดรเวอร์ หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีสร้างงานการนำส่งการจัดส่ง

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

หากต้องการสร้างงานการนำส่งการจัดส่งจากสภาพแวดล้อมเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST ให้เรียกใช้ HTTP REST ถึง CreateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน ต้องไม่ใช่หมายเลขติดตาม สำหรับการจัดส่ง หากไม่มีรหัสงานในระบบ คุณอาจสร้าง ตัวระบุที่ไม่ซ้ำกันทั่วโลก (UUID)

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  ประเภท	Type.DELIVERY
  รัฐ	State.OPEN
  trackingId	หมายเลขหรือตัวระบุที่คุณใช้ในการติดตามการจัดส่ง
  plannedLocation	ในกรณีนี้คือตำแหน่งที่งานจะเสร็จสิ้น สถานที่นำส่งสำหรับการจัดส่งนี้
  taskDuration	เวลาที่คาดว่าจะใช้ในการส่งคืนสินค้าซึ่งมีหน่วยเป็นวินาที ณ สถานที่จัดส่ง

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  targetTimeWindow	กรอบเวลาที่งานควรเสร็จสิ้น การดำเนินการนี้จะไม่ ส่งผลต่อลักษณะการทำงานของการกำหนดเส้นทาง
  แอตทริบิวต์	รายการแอตทริบิวต์งานที่กำหนดเอง แอตทริบิวต์แต่ละรายการต้องมีคีย์ที่ไม่ซ้ำกัน

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine ขว้าง ข้อยกเว้นหากคำขอมี deliveryVehicleId ที่กำหนด คุณมอบหมาย งานโดยใช้ UpdateDeliveryVehicleRequest สำหรับข้อมูลเพิ่มเติม โปรดดู มอบหมายงานให้ยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง curl

# 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

สร้างงานแบบกลุ่ม

คุณสร้างชุดงานจากสภาพแวดล้อมของเซิร์ฟเวอร์ได้โดยใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java สร้างงาน 2 รายการ งานแรกสำหรับบริการจัดส่งและอีกงานสำหรับรับสินค้า ตำแหน่งที่ตั้ง:

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

หากต้องการสร้างงานการนำส่งและการรับสินค้าจากสภาพแวดล้อมของเซิร์ฟเวอร์ ให้สร้าง การเรียก HTTP REST ไปยัง BatchCreateTasks:

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

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็น โทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี BatchCreateTasksRequest

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  คำขอ	อาร์เรย์<CreateTasksRequest>

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  ส่วนหัว	`DeliveryRequestHeader`

องค์ประกอบ CreateTasksRequest แต่ละรายการใน requests ต้องผ่านการตรวจสอบเดียวกัน เป็นคำขอ CreateTask ยกเว้นในกรณีที่ parent และ header เป็นช่องที่ไม่บังคับ หากมีการตั้งค่า ค่าดังกล่าวต้องเหมือนกับ ช่องที่เกี่ยวข้องที่ BatchCreateTasksRequest ระดับบนสุด โปรดดู สร้างงานรับสินค้าสำหรับการจัดส่ง และ สร้างงานการนำส่งการจัดส่ง สำหรับกฎการตรวจสอบ แต่ละรายการได้

สำหรับข้อมูลเพิ่มเติม โปรดดูเอกสารอ้างอิง API สำหรับ BatchCreateTasks (gRPC, REST)

ตัวอย่างคำสั่ง curl

# 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

ความไม่พร้อมให้บริการตามกำหนดการ

คุณสามารถสร้างงานที่ระบุว่าไม่ว่าง (เช่น สำหรับคนขับ ช่วงพักหรือการเติมน้ำมันรถ) จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST งานความไม่พร้อมใช้งานตามกำหนดเวลาต้องไม่มี รหัสติดตาม คุณสามารถระบุสถานที่ตั้งหรือไม่ก็ได้

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีสร้างงานที่ไม่พร้อมให้บริการ

    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

หากต้องการสร้างงานที่ไม่พร้อมใช้งานจากสภาพแวดล้อมของเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ถึง CreateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน หากไม่ มีรหัสงานในระบบ คุณอาจสร้างรหัสงานที่ไม่ซ้ำกันทั้งหมด (UUID)

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  ประเภท	Type.UNAVAILABLE
  รัฐ	State.OPEN
  taskDuration	ระยะเวลาของช่วงพักเป็นวินาที

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  plannedLocation	ตำแหน่งของช่วงพักหากต้องดำเนินการในสถานที่ที่เฉพาะเจาะจง

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine ขว้าง ข้อยกเว้นหากคำขอมี deliveryVehicleId ที่กำหนด คุณมอบหมาย งานโดยใช้ UpdateDeliveryVehicleRequest สำหรับข้อมูลเพิ่มเติม โปรดดู มอบหมายงานให้ยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง curl

    # 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

ป้ายจอดรถตามกำหนดการ

คุณสามารถสร้างงานการหยุดที่กำหนดเวลาไว้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST งานหยุดที่กำหนดเวลาไว้อาจไม่มีการติดตาม ID

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีสร้างงานการหยุดที่กำหนดเวลาไว้

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

หากต้องการสร้างงานการหยุดที่กำหนดเวลาไว้จากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ถึง CreateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน หากคุณไม่มี รหัสงานในระบบของคุณ คุณอาจสร้าง ตัวระบุที่ไม่ซ้ำกันทั่วโลก (UUID)

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  ประเภท	Type.SCHEDULED_STOP
  รัฐ	State.OPEN
  plannedLocation	ตำแหน่งของป้ายจอดรถ
  taskDuration	ความยาวที่คาดไว้ของจุดแวะ หน่วยเป็นวินาที

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่พิจารณาช่องอื่นๆ ทั้งหมดในเอนทิตีในการสร้าง Fleet Engine ขว้าง ข้อยกเว้นหากคำขอมี deliveryVehicleId ที่กำหนด คุณมอบหมาย งานโดยใช้ UpdateDeliveryVehicleRequest สำหรับข้อมูลเพิ่มเติม โปรดดู มอบหมายงานให้ยานพาหนะและ UpdateDeliveryVehicleRequest

ตัวอย่างคำสั่ง curl

    # 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

กำหนดกรอบเวลาเป้าหมาย

กรอบเวลาเป้าหมายคือ TimeWindow ในระหว่างที่ควรทำงานให้เสร็จ เช่น หากคุณสื่อสาร กรอบเวลาการนำส่งถึงผู้รับการนำส่ง คุณสามารถใช้เวลาเป้าหมายของงานได้ เพื่อจับภาพกรอบเวลานี้และสร้างการแจ้งเตือนหรือวิเคราะห์หลังการเดินทาง ประสิทธิภาพการทำงานโดยใช้ฟิลด์

โดยกรอบเวลาเป้าหมายจะประกอบด้วยเวลาเริ่มต้นและเวลาสิ้นสุด ซึ่งสามารถกำหนดได้ ในงานทุกประเภท กรอบเวลาเป้าหมายไม่มีผลต่อการกำหนดเส้นทาง พฤติกรรมของคุณ

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java ในการกำหนดกรอบเวลาของงาน ให้ทำดังนี้

    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

หากต้องการกำหนดกรอบเวลาของงานโดยใช้ HTTP ให้เรียกใช้ UpdateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  targetTimeWindow	กรอบเวลาที่งานควรเสร็จสิ้น การตั้งค่านี้ ไม่ส่งผลต่อการทำงานของการกำหนดเส้นทาง

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

# 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

ตั้งค่าการกำหนดค่าระดับการเข้าถึงการติดตามงาน

ระดับการเข้าถึงข้อมูลในไลบรารีการติดตามการจัดส่งและข้อมูลดังกล่าว ที่ส่งคืนจากการเรียกไปยัง GetTaskTrackingInfo จะควบคุมได้ในแบบต่องาน โดยการตั้งค่า TaskTrackingViewConfig ในงาน โปรดดู งานยานพาหนะที่ใช้งานอยู่ เพื่อดูข้อมูลเพิ่มเติม ซึ่งทำได้เมื่อสร้างหรืออัปเดต งาน ตัวอย่างของการอัปเดตงานด้วยการกำหนดค่านี้มีดังนี้

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java ในการกำหนดการกำหนดค่ามุมมองการติดตามงาน ให้ทำดังนี้

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

หากต้องการตั้งค่าหน้าต่างการกำหนดค่ามุมมองการติดตามงานโดยใช้ HTTP ให้เรียกใช้ UpdateTask

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  taskTrackingViewConfig	การกำหนดค่าสำหรับการติดตามงานที่ระบุว่าองค์ประกอบข้อมูลใด ปรากฏต่อผู้ใช้ปลายทางไม่ว่าในกรณีใด

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

# 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

มอบหมายงานให้ยานพาหนะ

คุณมอบหมายงานให้กับยานพาหนะที่นำส่งสินค้าได้ด้วยการอัปเดตลำดับงาน สำหรับยานพาหนะ การเรียงลำดับงานสำหรับยานพาหนะจะกำหนดตามรายการ ของจุดจอดสำหรับยานพาหนะที่นำส่ง และคุณสามารถมอบหมายงานได้ตั้งแต่ 1 อย่างขึ้นไป กับจุดจอดยานพาหนะแต่ละป้าย โปรดดูรายละเอียดที่หัวข้อ อัปเดตลำดับงาน

หากต้องการเปลี่ยนการจัดส่งจากยานพาหนะหนึ่งไปยังอีกคัน ให้ปิดงานเดิม และสร้างใหม่ก่อนที่จะกำหนดให้กับยานพาหนะใหม่ หากคุณอัปเดตงาน เรียงลำดับสำหรับงานที่มอบหมายแล้ว คุณจะพบข้อผิดพลาด

อัปเดตการเรียงลำดับงาน

คุณสามารถอัปเดตงานคำสั่งซื้อที่มอบหมายให้กับยานพาหนะได้จาก เวลา Driver SDK หรือสภาพแวดล้อมของเซิร์ฟเวอร์ อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยง สภาวะแข่งขันรอบข้าง และคงแหล่งข้อมูลที่เชื่อถือได้เพียงแหล่งเดียว

เมื่อคุณอัปเดตการเรียงลำดับงานสำหรับยานพาหนะ จะมีการดำเนินการดังต่อไปนี้ด้วย

• มอบหมายงานใหม่ๆ ให้กับยานพาหนะ
• ปิดงานที่เคยกำหนดให้รถแต่ไม่ได้รับ ในลำดับที่อัปเดต

หากต้องการเปลี่ยนการจัดส่งจากยานพาหนะหนึ่งเป็นอีกคัน ปิดงานเดิม และสร้างใหม่ก่อนที่จะกำหนดให้กับยานพาหนะใหม่ หากคุณอัปเดตงาน เรียงลำดับสำหรับงานที่มอบหมายแล้ว คุณจะพบข้อผิดพลาด

คุณอัปเดตลำดับงานได้ทุกเมื่อ

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่ออัปเดตการเรียงลำดับงานสำหรับยานพาหนะ โดยทำดังนี้

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

หากต้องการอัปเดตการจัดลำดับงานสำหรับยานพาหนะจากสภาพแวดล้อมเซิร์ฟเวอร์ ให้เรียกใช้ HTTP REST ถึง UpdateDeliveryVehicle:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำกันสำหรับยานพาหนะที่นำส่งในยานพาหนะของคุณ ที่คุณตั้งใจจะอัปเดตการเรียงลำดับงาน เป็นตัวระบุ ที่คุณระบุเมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  remainingVehicleJourneySegments	รายการกลุ่มเส้นทางสําหรับงานตามลำดับที่ควรดำเนินการ งานแรกในรายการจะดำเนินการก่อน
  remainingVehicleJourneySegments[i].stop	จุดแวะสำหรับงาน i ในรายการ
  remainingVehicleJourneySegments[i].stop.plannedLocation	สถานที่ที่วางแผนไว้สำหรับป้ายจอดรถ
  remainingVehicleJourneySegments[i].stop.tasks	รายการงานที่ต้องทำ ณ จุดแวะพักของยานพาหนะนี้
  remainingVehicleJourneySegments[i].stop.state	State.NEW

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

# 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

รถกำลังอยู่ระหว่างจอดไปยังจุดหมายถัดไป

Fleet Engine ต้องได้รับการแจ้งเตือนเมื่อยานพาหนะออกจากจุดแวะพักหรือสตาร์ท การนำทาง คุณสามารถแจ้ง Fleet Engine ได้จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงการมีเชื้อชาติ เงื่อนไข และเพื่อรักษาแหล่งข้อมูลที่ถูกต้องแห่งเดียว

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อแจ้ง Fleet Engine ว่ารถกำลังอยู่ระหว่างการขนส่งไปยังจุดแวะพักถัดไป

    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

วิธีแจ้งให้ Fleet Engine ทราบว่ามียานพาหนะกำลังขับไปยังจุดหมายถัดไปจาก สภาพแวดล้อมของเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง UpdateDeliveryVehicle:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำกันสำหรับยานพาหนะที่นำส่งในยานพาหนะของคุณ ที่คุณตั้งใจจะอัปเดตการเรียงลำดับงาน เป็นตัวระบุ ที่คุณระบุเมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก:

  ช่อง	ค่า
  remainingVehicleJourneySegments	รายการป้ายจอดรถที่เหลืออยู่ซึ่งมีรัฐมีสถานะเป็น "รัฐ" ใหม่ จุดแวะแรกในรายการต้องมีการทำเครื่องหมายสถานะเป็น State.ENROUTE

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสําหรับการแจ้งเตือน

ตัวอย่างคำสั่ง curl

# 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

อัปเดตตำแหน่งของรถ

หากไม่ได้ใช้ Driver SDK เพื่ออัปเดตตำแหน่งของรถ คุณสามารถดำเนินการ โทรหา Fleet Engine โดยตรงพร้อมระบุตำแหน่งของรถ สำหรับยานพาหนะที่ใช้งานอยู่ Fleet Engine คาดว่าจะอัปเดตตำแหน่งอย่างน้อย 1 ครั้งทุกนาทีและมากที่สุด 1 ครั้งทุก 5 วินาที

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีอัปเดตตำแหน่งของรถใน Fleet Engine

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

หากต้องการอัปเดตตำแหน่งของรถใน Fleet Engine โดยใช้ HTTP REST โปรดโทรหา UpdateDeliveryVehicle:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับยานพาหนะที่นำส่งสินค้าใน หรือที่คุณตั้งใจจะอัปเดตตำแหน่ง เป็นตัวระบุ ที่คุณระบุเมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก:

  ช่อง	ค่า
  lastLocation.supplementalLocation	ตำแหน่งของยานพาหนะ
  lastLocation.supplementalLocationTime	การประทับเวลาล่าสุดที่ทราบที่ยานพาหนะอยู่ที่ตำแหน่งนี้
  lastLocation.supplementalLocationSensor	ควรป้อนข้อมูล CUSTOMER_SUPPLIED_LOCATION

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  lastLocation.supplementalLocationAccuracy	ความแม่นยำของตำแหน่งที่ระบุ หน่วยเป็นเมตร

ตัวอย่างคำสั่ง curl

# 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

รถมาถึงจุดแวะ

คุณต้องแจ้ง Fleet Engine เมื่อยานพาหนะมาถึงจุดแวะพัก คุณสามารถแจ้งได้ Fleet Engine จาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงการมีเชื้อชาติ เงื่อนไข และเพื่อรักษาแหล่งข้อมูลที่ถูกต้องแห่งเดียว

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อแจ้ง Fleet Engine ว่ายานพาหนะมาถึงจุดแวะ ให้ทำดังนี้

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

วิธีแจ้ง Fleet Engine เกี่ยวกับการมาถึงของยานพาหนะที่จุดแวะจากสภาพแวดล้อมของเซิร์ฟเวอร์ เรียก HTTP REST ไปยัง UpdateDeliveryVehicle:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำกันสำหรับยานพาหนะที่นำส่งในยานพาหนะของคุณ ที่คุณตั้งใจจะอัปเดตการเรียงลำดับงาน เป็นตัวระบุ ที่คุณระบุเมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  remainingVehicleJourneySegments	จุดแวะพักไปถึงโดยกำหนดสถานะเป็น State.ARRIVED ตามด้วยรายการป้ายจอดรถที่เหลืออยู่ที่มีสถานะเป็นรัฐใหม่

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

# 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

รถจอดสมบูรณ์

คุณต้องแจ้ง Fleet Engine เมื่อยานพาหนะจอดเสร็จแล้ว ซึ่งทำให้ งานทั้งหมดที่เชื่อมโยงกับจุดแวะเพื่อตั้งค่าเป็นสถานะ "ปิด" คุณสามารถ แจ้งให้ Fleet Engine ทราบจาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST อย่าใช้ทั้ง 2 วิธีเพื่อหลีกเลี่ยงสภาวะการแข่งขันและคงแหล่งข้อมูลที่เชื่อถือได้เพียงแหล่งเดียว

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อแจ้ง Fleet Engine ว่ารถจอดเรียบร้อยแล้ว

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

วิธีแจ้งให้ Fleet Engine ทราบเกี่ยวกับการหยุดจากสภาพแวดล้อมของเซิร์ฟเวอร์เสร็จสมบูรณ์แล้ว เรียก HTTP REST ไปยัง UpdateDeliveryVehicle:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำกันสำหรับยานพาหนะที่นำส่งในยานพาหนะของคุณ ที่คุณตั้งใจจะอัปเดตการเรียงลำดับงาน เป็นตัวระบุ ที่คุณระบุเมื่อสร้างยานพาหนะ

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี DeliveryVehicle

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  remaining_vehicle_journey_segments	จุดแวะที่คุณดำเนินการเสร็จแล้วไม่ควรอยู่ในรายการ จุดจอดยานพาหนะที่เหลืออยู่

• ช่องที่ไม่บังคับมีดังนี้

  • ไม่มี

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

    # 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

อัปเดตงาน

ช่องงานส่วนใหญ่จะเปลี่ยนแปลงไม่ได้ อย่างไรก็ตาม คุณสามารถแก้ไขสถานะ ผลลัพธ์งาน เวลาผลลัพธ์ของงาน ตำแหน่งที่ตั้งผลลัพธ์ของงาน และแอตทริบิวต์ตาม อัปเดตเอนทิตีงานโดยตรง ตัวอย่างเช่น ในกรณีที่งาน ถูกกำหนดให้กับยานพาหนะ คุณสามารถปิดงานได้โดยการอัปเดต รัฐนั้นโดยตรง

gRPC

นี่คือตัวอย่างของการอัปเดตงานผ่าน gRPC

REST

นี่คือตัวอย่างของการอัปเดตงานผ่าน REST

ปิดงาน

หากต้องการปิดงานที่มอบหมายให้กับยานพาหนะแล้ว ให้ แจ้ง Fleet Engine ว่ารถได้ทำการแวะพักที่งานเสร็จ หรือนำออกจากรายการป้ายจอดรถ คุณสามารถทำได้โดยกำหนดรายการ ยานพาหนะที่เหลือจะหยุดเหมือนตอนที่อัปเดตการเรียงลำดับงาน สำหรับยานพาหนะ

หากยังไม่ได้มอบหมายงานในรถยนต์และจำเป็นต้องปิด ให้อัปเดตงาน เป็นสถานะ "ปิด" แต่คุณจะเปิดงานที่ปิดไปแล้วอีกไม่ได้

การปิดงานไม่ได้บ่งบอกถึงความสำเร็จหรือล้มเหลว โดยระบุว่า งานนั้นจะไม่ถือว่าอยู่ระหว่างดำเนินการอีกต่อไป สำหรับการติดตามการจัดส่ง สิ่งสำคัญคือการบ่งชี้ผลลัพธ์ที่แท้จริงของงานเพื่อให้การส่ง แสดงผลลัพธ์ได้

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

หากต้องการทำเครื่องหมายงานว่าปิดแล้วจากสภาพแวดล้อมของเซิร์ฟเวอร์ ให้เรียก HTTP REST ไปยัง UpdateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

คุณต้องรวมเอนทิตี Task ไว้ในเนื้อหาของคำขอ

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  รัฐ	State.CLOSED

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  taskOutcome	ผลลัพธ์.SUCCEEDED หรือผลลัพธ์ล้มเหลว
  taskOutcomeTime	เวลาที่งานเสร็จ
  taskOutcomeLocation	ตำแหน่งที่งานเสร็จแล้ว Fleet Engine กำหนดค่าเริ่มต้นนี้ไว้ ไปยังตำแหน่งสุดท้ายของยานพาหนะ ยกเว้นในกรณีที่ผู้ให้บริการลบล้างด้วยตนเอง

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

    # 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

กำหนดผลลัพธ์ของงานและตำแหน่งผลลัพธ์

การปิดงานไม่ได้บ่งบอกถึงความสำเร็จหรือล้มเหลว แต่เป็นตัวบ่งชี้ว่า งานนั้นจะไม่ถือว่าอยู่ระหว่างดำเนินการอีกต่อไป สำหรับการติดตามการจัดส่ง สิ่งสำคัญคือการบ่งชี้ผลลัพธ์ที่แท้จริงของงาน เพื่อให้ ผลลัพธ์การนำส่งจะแสดงได้ และมีการเรียกเก็บเงินที่เหมาะสมสำหรับบริการ เมื่อตั้งค่าแล้ว คุณจะเปลี่ยนผลลัพธ์ของงานไม่ได้ อย่างไรก็ตาม คุณสามารถแก้ไข เวลาของผลลัพธ์งานและตำแหน่งผลลัพธ์ของงานหลังจากที่ตั้งค่าแล้ว

งานที่อยู่ในสถานะ "ปิด" สามารถกำหนดผลลัพธ์เป็น สำเร็จหรือไม่สำเร็จ Fleet Engine จะเรียกเก็บเงินเฉพาะงานนำส่งที่มีสถานะเป็น สำเร็จ

เมื่อทำเครื่องหมายผลลัพธ์ของงาน Fleet Engine จะเติมข้อมูลในช่อง ตำแหน่งผลการค้นหางานที่มีตำแหน่งยานพาหนะที่ทราบล่าสุด คุณสามารถ ลบล้างลักษณะการทำงานนี้

gRPC

คุณจะมีตัวเลือกในการตั้งค่าตำแหน่งผลลัพธ์ของงานเมื่อตั้งค่า ผลลัพธ์ การตั้งค่าตำแหน่งจะป้องกันไม่ให้ Fleet Engine ตั้งค่า เป็นค่าเริ่มต้นของพารามิเตอร์สุดท้าย ตำแหน่งรถ คุณยังเขียนทับ Fleet Engine ในตำแหน่งผลลัพธ์ของงานได้ด้วย กำหนดในภายหลัง Fleet Engine จะไม่เขียนทับตำแหน่งผลลัพธ์ของงาน ที่คุณให้ไว้ คุณไม่สามารถตั้งค่าตำแหน่งผลลัพธ์ของงานสำหรับงานได้ ซึ่งไม่ได้กำหนดผลลัพธ์งานไว้ คุณกำหนดได้ทั้งผลลัพธ์ของงาน และตำแหน่งผลลัพธ์ของงานภายในคำขอเดียวกัน

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อกำหนดผลลัพธ์ของงานเป็น SUCCEEDED และกำหนดตำแหน่งที่งาน เสร็จสมบูรณ์:

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

หากต้องการทำเครื่องหมายงานว่าเสร็จสมบูรณ์จากสภาพแวดล้อมของเซิร์ฟเวอร์ เรียก HTTP REST ไปยัง UpdateTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องมีเอนทิตี Task

• ช่องที่ต้องกรอก

  ช่อง	ค่า
  taskOutcome	ผลลัพธ์.SUCCEEDED หรือผลลัพธ์ล้มเหลว

• ช่องที่ไม่บังคับมีดังนี้

  ช่อง	ค่า
  taskOutcomeLocation	ตำแหน่งที่งานเสร็จแล้ว หากไม่ได้ตั้งค่าไว้ Fleet Engine ตั้งค่าตำแหน่งนี้เป็นตำแหน่งสุดท้ายของรถเป็นค่าเริ่มต้น
  taskOutcomeTime	การประทับเวลาเมื่องานเสร็จสมบูรณ์

ระบบจะไม่สนใจช่องอื่นๆ ทั้งหมดในเอนทิตีสำหรับการอัปเดต

ตัวอย่างคำสั่ง curl

# 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

กำหนดเส้นทางการจัดส่งใหม่

เมื่อสร้างงานการจัดส่งแล้ว คุณจะเปลี่ยนตำแหน่งที่วางแผนไว้ไม่ได้ หากต้องการเปลี่ยนเส้นทางการจัดส่ง ให้ปิดงานการจัดส่งโดยไม่ตั้งค่า ผลลัพธ์ แล้วสร้างงานใหม่ซึ่งมีตำแหน่งที่วางแผนไว้ที่อัปเดต หลังจากสร้างงานใหม่แล้ว ให้มอบหมายงานให้กับรถยนต์คันเดิม สำหรับข้อมูลเพิ่มเติม โปรดดูหัวข้อปิดงานการจัดส่งและ มอบหมายงาน

ใช้เครื่องให้อาหารและยานพาหนะนำส่ง

หากใช้ยานพาหนะฟีดเดอร์ในการขนส่งการจัดส่งไปยังยานพาหนะนำส่ง ตลอดทั้งวัน จำลองการโอนการจัดส่งเป็นงานที่มีกำหนดการหยุดพัก สำหรับยานพาหนะที่นำส่งสินค้า เพื่อให้การติดตามตำแหน่งถูกต้อง ให้กำหนด งานการนำส่งการจัดส่งสำหรับการจัดส่งที่โอนหลังจากที่มีการขนย้ายลงไปยัง สำหรับยานพาหนะที่นำส่งสินค้า ดูข้อมูลเพิ่มเติมได้ที่จุดแวะพักที่ตั้งเวลาไว้

สถานะการจัดส่งร้านค้าและข้อมูลเมตาอื่นๆ

เมื่องานจัดส่งเสร็จสมบูรณ์แล้ว ระบบจะบันทึกสถานะงานและผลลัพธ์ของงาน ในงาน อย่างไรก็ตาม คุณอาจต้องการอัปเดตข้อมูลเมตาอื่นๆ สำหรับการจัดส่งโดยเฉพาะ ในการจัดเก็บข้อมูลเมตาอื่นๆ ที่คุณสามารถ การอ้างอิงภายนอกบริการ Fleet Engine ให้ใช้ Tracking_id ที่เกี่ยวข้อง กับงานเป็นคีย์ในตารางภายนอก

ดูข้อมูลเพิ่มเติมได้ที่ช่วงชีวิตของงาน

ค้นหายานพาหนะ

คุณสามารถค้นหายานพาหนะจาก Driver SDK หรือจากสภาพแวดล้อมของเซิร์ฟเวอร์ที่ใช้ gRPC หรือ REST

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีค้นหารถ

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

หากต้องการค้นหารถยนต์จากสภาพแวดล้อมของเซิร์ฟเวอร์ เรียก HTTP REST ไปยัง GetVehicle:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน

&lt;vehicleId&gt; คือรหัสของยานพาหนะที่จะค้นหา

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องว่างเปล่า

หากค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีเอนทิตียานพาหนะ

ตัวอย่างคำสั่ง curl

# 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}"

ค้นหางาน

คุณค้นหางานจากสภาพแวดล้อมของเซิร์ฟเวอร์ได้โดยใช้ gRPC หรือ REST Driver SDK ไม่ รองรับการค้นหางาน

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java วิธีค้นหางาน

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

หากต้องการค้นหางานจากสภาพแวดล้อมของเซิร์ฟเวอร์ เรียก HTTP REST ไปยัง GetTask:

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

&lt;id&gt; คือตัวระบุที่ไม่ซ้ำสำหรับงาน

&lt;taskId&gt; คือรหัสของงานที่จะค้นหา

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

เนื้อหาของคำขอต้องว่างเปล่า

หากค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีเอนทิตีงาน

ตัวอย่างคำสั่ง curl

    # 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}"

ค้นหาข้อมูลงานการจัดส่งตามรหัสติดตาม

คุณค้นหาข้อมูลงานการจัดส่งได้ด้วยวิธีต่อไปนี้ ซึ่งแต่ละแบบมีวัตถุประสงค์ต่างกัน ดังนี้

• ตามรหัสงาน: ใช้โดยผู้ใช้ เช่น ผู้ให้บริการกลุ่มยานพาหนะที่มีสิทธิ์เข้าถึง มุมมองแบบเต็มของข้อมูลงาน
• ตามรหัสติดตาม: ซอฟต์แวร์ไคลเอ็นต์ใช้เพื่อให้การจำกัด ให้แก่ผู้ใช้ปลายทาง เช่น เวลาที่คาดว่าจะได้รับพัสดุที่บ้าน

ส่วนนี้จะกล่าวถึงการค้นหาข้อมูลงานตามรหัสติดตาม หากคุณต้องการ หากต้องการค้นหางานตามรหัสงาน ให้ไปที่ค้นหางาน

หากต้องการค้นหาข้อมูลตามรหัสติดตาม คุณสามารถใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้

• การค้นหาด้วย Java โดยใช้ gRPC
• การค้นหาโดยใช้ HTTP

ข้อกำหนดในการค้นหา

• ข้อมูลการจัดส่งที่ระบุโดยรหัสติดตามเป็นไปตามกฎระดับการเข้าถึง ระบุไว้ใน ควบคุมการมองเห็นสถานที่ที่ติดตาม

• ใช้ Fleet Engine เพื่อค้นหาข้อมูลการจัดส่งด้วยรหัสติดตาม ผู้ขับขี่ SDK ไม่รองรับการค้นหาข้อมูลด้วยรหัสติดตาม หากต้องการดำเนินการดังกล่าวกับ Fleet เครื่องมือค้นหา คุณจะใช้สภาพแวดล้อมของเซิร์ฟเวอร์หรือเบราว์เซอร์ก็ได้

• ใช้โทเค็นที่แคบที่สุดเท่าที่ทำได้เพื่อจำกัดความเสี่ยงด้านความปลอดภัย ตัวอย่างเช่น หากคุณ ใช้ Delivery Consumer Token, การเรียก Fleet Engine Deliveries API ที่แสดง เฉพาะข้อมูลที่เกี่ยวข้องกับผู้ใช้ปลายทาง เช่น ผู้จัดส่งหรือ เป็นผู้รับพัสดุ ส่วนข้อมูลอื่นๆ ทั้งหมดในคำตอบจะได้รับการปกปิด โปรดดูข้อมูลเพิ่มเติมเกี่ยวกับโทเค็นที่ การสร้าง JSON Web Token (JWT) สำหรับการให้สิทธิ์

การค้นหาด้วย Java โดยใช้ gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อค้นหาข้อมูลเกี่ยวกับงานการจัดส่งตามรหัสติดตาม

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;
}

การค้นหาโดยใช้ HTTP

หากต้องการค้นหางานการจัดส่งจากเบราว์เซอร์ ให้เรียก HTTP REST ไปยัง GetTaskTrackingInfo:

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

&lt;tracking_id&gt; คือรหัสติดตามที่เชื่อมโยงกับงาน

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> เป็น โทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

หากการค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีแอตทริบิวต์ taskTrackingInfo เอนทิตี

ตัวอย่างคำสั่ง curl

# 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}"

แสดงรายการงาน

คุณแสดงรายการงานจากเซิร์ฟเวอร์หรือสภาพแวดล้อมของเบราว์เซอร์ได้ Driver SDK ไม่ สนับสนุนการแสดงรายการงาน

งานในรายการจะขอสิทธิ์เข้าถึงงานแบบกว้าง งานแสดงรายการมีไว้เพื่อ ผู้ใช้ที่เชื่อถือได้ ใช้ Delivery Fleet Reader หรือ Delivery Super User Authentication โทเค็นเมื่อสร้างรายการคำของาน

งานที่ระบุมีการปกปิดช่องต่อไปนี้

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

พร็อพเพอร์ตี้งานส่วนใหญ่สามารถกรองงานที่ระบุไว้ตามพร็อพเพอร์ตี้งานได้ สำหรับไวยากรณ์การค้นหาตัวกรอง โปรดดู AIP-160 รายการต่อไปนี้แสดงงานที่ถูกต้อง พร็อพเพอร์ตี้ที่ใช้กรองได้:

• แอตทริบิวต์
• delivery_vehicle_id
• รัฐ
• planned_location
• task_duration
• task_outcome
• task_outcome_location
• task_outcome_location_source
• task_outcome_time
• tracking_id
• ประเภท

ใช้รูปแบบช่องต่อไปนี้ตามข้อเสนอการปรับปรุง Google API

ชนิดของฟิลด์	รูปแบบ	ตัวอย่าง
การประทับเวลา	RFC-3339	task_outcome_time = 2022-03-01T11:30:00-08:00
ระยะเวลา	จำนวนวินาทีที่ตามด้วย s	task_duration = 120s
ค่าแจกแจง	สตริง	state = CLOSED AND type = PICKUP
ตำแหน่ง	point.latitude และ point.longitude	planned_location.point.latitude > 36.1 AND planned_location.point.longitude < -122.0

ดู AIP-160 สำหรับรายการคำสืบค้นตัวกรองทั้งหมด โอเปอเรเตอร์

หากไม่ได้ระบุการค้นหาตัวกรองไว้ ระบบจะแสดงงานทั้งหมด

มีการแบ่งหน้ารายการงานแล้ว ขนาดหน้าเว็บสามารถระบุในคำของานรายการได้ หากระบุขนาดหน้า จำนวนงานที่ส่งคืนจะไม่มากกว่า ใหญ่กว่าขนาดหน้าที่ระบุ หากไม่มีขนาดหน้า จะใช้ค่าเริ่มต้นที่สมเหตุสมผล หากขนาดหน้าที่ขอเกินค่าสูงสุดภายใน จากนั้นจะใช้ค่าสูงสุดภายใน

รายการงานอาจมีโทเค็นสำหรับอ่านผลการค้นหาหน้าถัดไปได้ ใช้โทเค็นของหน้าเว็บกับคำขอที่เหมือนกับคำขอก่อนหน้า เพื่อเรียกข้อมูลหน้าถัดไปของงาน เมื่อโทเค็นหน้าเว็บที่ส่งกลับ ว่างเปล่า ไม่สามารถเรียกข้อมูลงานได้อีก

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อแสดงรายการงานสำหรับ deliveryVehicleId และแอตทริบิวต์งาน สำเร็จ การตอบกลับยังคงว่างเปล่าได้ การตอบกลับที่ว่างเปล่าหมายความว่าไม่มี Tasks เชื่อมโยง DeliveryVehicleId ที่ให้ไว้

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

หากต้องการแสดงรายการงานจากเบราว์เซอร์ ให้เรียก HTTP REST ไปยัง ListTasks

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

หากต้องการใช้ตัวกรองกับงานที่แสดง ให้ใส่ "ตัวกรอง" พารามิเตอร์ของ URL ที่มีการค้นหาตัวกรองที่ใช้ Escape กับ URL เป็นค่า

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

หากการค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีข้อมูลที่มีโครงสร้างต่อไปนี้

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

การตอบกลับที่สำเร็จอาจว่างเปล่า คำตอบที่ว่างเปล่าคือไม่ พบว่างานที่ตรงตามเกณฑ์ตัวกรองที่ระบุ

ตัวอย่างคำสั่ง curl

    # 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}"

แสดงรายการยานพาหนะสำหรับนำส่ง

คุณแสดงรายการยานพาหนะสำหรับนำส่งได้จากเซิร์ฟเวอร์หรือสภาพแวดล้อมของเบราว์เซอร์ ผู้ขับขี่ SDK ไม่รองรับยานพาหนะสำหรับนำส่งข้อมูล

ยานพาหนะสำหรับนำส่งข้อมูลขอสิทธิ์เข้าถึงแบบกว้างสำหรับยานพาหนะสำหรับนำส่งสินค้าและ มีไว้สำหรับผู้ใช้ที่เชื่อถือได้เท่านั้น ใช้ Delivery Fleet Reader หรือ Delivery Super โทเค็นการตรวจสอบสิทธิ์ผู้ใช้เมื่อสร้างรายการคำขอยานพาหนะนำส่ง

ยานพาหนะสำหรับนำส่งที่ระบุไว้มีการปกปิดช่องต่อไปนี้เนื่องจากผลกระทบ ในขนาดการตอบกลับ:

• CurrentRouteSegment
• RemainingVehicleJourneySegments

คุณกรองรายการยานพาหนะสำหรับนำส่งสินค้าได้ตามพร็อพเพอร์ตี้ attributes สำหรับ ตัวอย่างเช่น หากต้องการค้นหาแอตทริบิวต์ที่มีคีย์ my_key และค่า my_value ให้ใช้ attributes.my_key = my_value หากต้องการค้นหาแอตทริบิวต์หลายรายการ ให้รวมการค้นหาเข้าด้วยกัน โดยใช้โอเปอเรเตอร์ AND และ OR แบบลอจิคัล เช่น attributes.key1 = value1 AND attributes.key2 = value2 ดู AIP-160 สำหรับข้อมูล คำอธิบายไวยากรณ์คำค้นหาตัวกรอง

คุณสามารถกรองยานพาหนะสำหรับนำส่งสินค้าที่แสดงตามสถานที่ตั้งได้โดยใช้คำขอviewport พารามิเตอร์ พารามิเตอร์คำขอ viewport กำหนดวิวพอร์ตโดยใช้ขอบเขต 2 แบบ พิกัด: ละติจูดและลองจิจูด high (ตะวันออกเฉียงเหนือ) และ low (ตะวันตกเฉียงใต้) คู่พิกัด คำขอจะถูกปฏิเสธหากมีละติจูดสูง ที่มีตำแหน่งทางภูมิศาสตร์ต่ำกว่าละติจูดต่ำ

ระบบจะใส่เลขหน้าให้กับรายการยานพาหนะสำหรับนำส่งโดยค่าเริ่มต้นโดยใช้ขนาดหน้าที่เหมาะสม ถ้า ที่คุณระบุขนาดหน้าเว็บ คำขอจะแสดงเฉพาะจำนวนยานพาหนะ ตามขีดจำกัดหรือน้อยกว่า หากขนาดหน้าที่ขอเกินขนาดภายใน ระบบจะใช้ค่าสูงสุดภายใน หน้าเว็บเริ่มต้นและหน้าสูงสุด ขนาดต่างๆ เป็นยานพาหนะ 100 คัน

รายการยานพาหนะที่นำส่งสามารถรวมโทเค็นสำหรับอ่านหน้าถัดไปของ รายการ โทเค็นหน้าจะแสดงเฉพาะในการตอบสนองเมื่อมีหน้าการแสดงโฆษณามากขึ้นเท่านั้น และสามารถนำรถมาคืนได้ หากต้องการดึงข้อมูลหน้าถัดไปของงาน ให้ใช้ โทเค็นหน้าเว็บที่มีคำขอที่เหมือนกับ อีกครั้ง

gRPC

ตัวอย่างต่อไปนี้จะแสดงวิธีใช้ ไลบรารี gRPC ของ Java เพื่อแสดงยานพาหนะที่นำส่งในภูมิภาคหนึ่งๆ โดยมีแอตทริบิวต์ที่เฉพาะเจาะจง ต การตอบกลับที่สำเร็จจะยังคงว่างเปล่า เมื่อเป็นเช่นนี้ ก็หมายความว่า ยานพาหนะที่มีแอตทริบิวต์ที่ระบุอยู่ในวิวพอร์ตที่ระบุแล้ว

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

หากต้องการแสดงรายการงานจากเบราว์เซอร์ ให้เรียก HTTP REST ไปยัง ListDeliveryVehicles

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

หากต้องการใช้ตัวกรองกับงานที่แสดง ให้ใส่ "ตัวกรอง" พารามิเตอร์ของ URL ที่มี การค้นหาตัวกรองที่ใช้ Escape กับ URL เป็นค่า

ส่วนหัวของคำขอต้องมีช่อง Authorization ที่มีค่า Bearer <token> โดยที่ <token> คือโทเค็นที่ออกโดยโรงงานโทเค็น Fleet Engine

หากการค้นหาสำเร็จ เนื้อหาการตอบกลับจะมีข้อมูลที่มีโครงสร้างต่อไปนี้

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

การตอบกลับที่สำเร็จอาจว่างเปล่า เมื่อเป็นเช่นนี้ ก็หมายความว่า พบยานพาหนะนำส่งที่เป็นไปตามคำค้นหาตัวกรองและวิวพอร์ตที่ระบุ

ตัวอย่างคำสั่ง curl

# 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"

การติดตามการจัดส่ง

คุณมี 2 ตัวเลือกในการใช้ Fleet Engine Deliveries API เพื่อเปิดใช้การติดตามการจัดส่ง

• แนะนำ: ใช้ ไลบรารีการติดตามการจัดส่งแบบ JavaScript คลังช่วยให้คุณเห็นภาพตำแหน่งของยานพาหนะและสถานที่ต่างๆ ติดตามความสนใจใน Fleet Engine มีคอมโพเนนต์แผนที่ JavaScript ซึ่งเป็นการแทนที่วัตถุ google.maps.Map มาตรฐานแบบดรอปอิน และข้อมูลที่จะเชื่อมต่อกับ Fleet Engine คอมโพเนนต์นี้ช่วยให้คุณ มอบประสบการณ์การติดตามการจัดส่งแบบเคลื่อนไหวที่ปรับแต่งได้ จากเว็บหรือแอปพลิเคชันบนอุปกรณ์เคลื่อนที่

• ใช้การติดตามการจัดส่งของคุณเองนอกเหนือจาก Fleet Engine Deliveries API

สิ่งสำคัญคือการค้นหางานการจัดส่งโดยใช้รหัสติดตาม

หากคุณใช้บทบาทผู้บริโภคในการนำส่ง การเรียก API การนำส่งของ Fleet Engine ส่งคืนเฉพาะข้อมูลที่เกี่ยวข้องกับผู้จัดส่งหรือผู้รับเท่านั้น อื่นๆ ทั้งหมด ข้อมูลในคำตอบจะได้รับการปกปิด คุณมีความรับผิดชอบ สำหรับการตรวจสอบสิทธิ์ผู้ใช้ปลายทาง นอกจากนี้ ข้อมูลตำแหน่งยังถูกกรอง ตามงานที่ทำอยู่แล้ว ระหว่างงานที่ไม่พร้อมใช้งาน จะไม่มีการแชร์ข้อมูลตำแหน่งกับผู้ใช้ปลายทาง

การบันทึก

คุณสามารถตั้งค่า Fleet Engine ให้ส่งบันทึก RPC ไปยัง Cloud Logging สำหรับข้อมูลเพิ่มเติม ดูข้อมูลได้ที่ การบันทึก

บทบาทและโทเค็นการให้สิทธิ์

ตามที่อธิบายไว้ในหัวข้อจัดการรถยนต์และวงจรงาน และหมายเหตุการให้สิทธิ์สำหรับ กรณีการใช้งาน แต่ละรายการ การเรียก Fleet Engine ต้องมีการตรวจสอบสิทธิ์ด้วย JSON Web Token ที่มี ลงนามโดยใช้ข้อมูลเข้าสู่ระบบของบัญชีบริการแล้ว บัญชีบริการที่ใช้ ในการออกโทเค็นเหล่านั้นอาจมี 1 บทบาทขึ้นไป โดยแต่ละบทบาทจะ สิทธิ์อีกชุดหนึ่ง

สำหรับข้อมูลเพิ่มเติม โปรดดู การตรวจสอบสิทธิ์และการให้สิทธิ์

แก้ไขปัญหาทั่วไป

หากคุณพบปัญหาใดๆ โปรดดูส่วนต่อไปนี้เพื่อรับความช่วยเหลือ

ความยืดหยุ่น

Fleet Engine ไม่ถือเป็นแหล่งข้อมูลที่เชื่อถือได้ คุณมีความรับผิดชอบ ในการคืนค่าสถานะระบบของคุณ ถ้าจำเป็น โดยไม่ต้อง Fleet Engine

สถานะสูญหายใน Fleet Engine

เมื่อทำงานกับ Fleet Engine ให้ใช้ไคลเอ็นต์เพื่อให้ระบบเยียวยา หากมีความล้มเหลว เช่น เมื่อ Fleet Engine พยายามอัปเดต รถยนต์อาจตอบสนองพร้อมด้วยข้อผิดพลาดที่ระบุว่ายานพาหนะไม่ได้ ที่มีอยู่ จากนั้นลูกค้าควรสร้างยานพาหนะใหม่ในสถานะใหม่ แม้ว่า ปัญหานี้เกิดขึ้นไม่บ่อยนัก โปรดตรวจสอบว่าระบบมีความยืดหยุ่นพอที่จะจัดการกับ ได้

ในสถานการณ์ที่แทบไม่น่าเป็นไปได้อย่างมากของความล้มเหลวครั้งใหญ่ของ Fleet Engine คุณอาจต้องสร้างยานพาหนะและงานส่วนใหญ่หรือทั้งหมดขึ้นใหม่ หากอัตราการสร้าง สูงเกินไป คำขอบางรายการอาจล้มเหลวอีกครั้งเนื่องจากปัญหาด้านโควต้าตั้งแต่ มีการตรวจสอบโควต้าเพื่อหลีกเลี่ยงการโจมตีแบบปฏิเสธการให้บริการ (DOS) ในกรณีนี้ ให้ชะลออัตราการสันทนาการลงโดยใช้กลยุทธ์ Backoff ใหม่

สถานะสูญหายในแอปคนขับ

หากแอปคนขับขัดข้อง แอปจะต้องสร้างสถานะปัจจุบันใหม่ ภายใน Driver SDK แอปควรพยายามสร้างงานขึ้นใหม่ ที่มีอยู่ และเพื่อเรียกคืนสถานะปัจจุบัน แอปควรทำดังนี้ สร้างรายชื่อและตั้งรายการจุดแวะสำหรับ Driver SDK อย่างชัดเจน

คำถามที่พบบ่อย

จะเกิดอะไรขึ้นถ้าคนขับหยุดงานผิดลำดับ

ในกรณีนี้ ให้อัปเดตลำดับของงานก่อน แล้วดำเนินการต่อตามปกติ ทําเครื่องหมายว่าถึงป้ายหยุด งานเสร็จแล้ว และรายละเอียดอื่นๆ ไม่เช่นนั้นระบบอาจทำงานไม่สอดคล้อง เวลาถึงโดยประมาณอาจไม่ถูกต้อง และอาจรายงานข้อผิดพลาดที่ไม่คาดคิด