Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

รับและตอบกลับการโต้ตอบของผู้ใช้

หน้านี้อธิบายวิธีที่แอป Google Chat รับและตอบสนองต่อการโต้ตอบของผู้ใช้ใน Google Chat

หากต้องการสร้างอินเทอร์เฟซแบบอินเทอร์แอกทีฟสำหรับแอป Chat คุณต้องใช้คอมโพเนนต์ต่อไปนี้

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

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

แอป Chat สามารถสร้างและแสดงอินเทอร์เฟซได้ด้วยวิธีต่อไปนี้

ข้อความที่มีข้อความ การ์ดแบบคงที่หรือแบบอินเทอร์แอกทีฟ และปุ่มอุปกรณ์เสริม
หน้าแรก (หน้าแรกของแอป) ที่ปรากฏ ในแท็บหน้าแรกของข้อความส่วนตัวแบบ 1:1 ด้วย แอป Chat
กล่องโต้ตอบ ซึ่งเป็นการ์ดที่เปิดในหน้าต่างใหม่ และมักจะแจ้งให้ผู้ใช้ส่งข้อมูล
ตัวอย่างลิงก์ ซึ่งเป็นการ์ดที่แสดงตัวอย่าง ข้อมูลเกี่ยวกับบริการภายนอก

ข้อกำหนดเบื้องต้น

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

วิธีการทำงานของการโต้ตอบของผู้ใช้

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

แผนภาพต่อไปนี้แสดงวิธีที่แอป Google Chat ประมวลผลและตอบกลับ การโต้ตอบของผู้ใช้

สถาปัตยกรรมของวิธีที่แอป Google Chat ประมวลผลการโต้ตอบของผู้ใช้

ทริกเกอร์

ทริกเกอร์คือวิธีเฉพาะ ที่ผู้ใช้เรียกใช้แอป Chat โดยใช้ UI ของ Chat เช่น การใช้ @พูดถึงหรือคำสั่งของแอป

ตารางต่อไปนี้แสดงทริกเกอร์ของ Chat, คำอธิบาย และวิธีที่แอป Chat มักจะตอบกลับ

ทริกเกอร์	คำอธิบาย	การตอบกลับโดยทั่วไป
เพิ่มไปยังพื้นที่ทำงานแล้ว	ผู้ใช้เพิ่มแอป Chat ลงในพื้นที่ทำงาน หรือ ผู้ดูแลระบบ Google Workspace ติดตั้ง แอป Chat ในพื้นที่ข้อความส่วนตัวสำหรับผู้ใช้ใน องค์กร หากต้องการดูข้อมูลเกี่ยวกับแอปใน Chat ที่ผู้ดูแลระบบติดตั้ง โปรดดูติดตั้งแอปใน Marketplace ลงในโดเมนในเอกสารประกอบความช่วยเหลือสำหรับผู้ดูแลระบบ Google Workspace	แอป Chat จะส่งข้อความเริ่มต้นใช้งานที่อธิบายสิ่งที่แอปทำและวิธีที่ผู้ใช้ในพื้นที่ทำงานโต้ตอบกับแอป
ข้อความ	ผู้ใช้โต้ตอบกับแอป Chat ใน ข้อความด้วยวิธีใดวิธีหนึ่งต่อไปนี้ ส่งข้อความในพื้นที่ข้อความส่วนตัว (DM) ด้วย แอป Chat @พูดถึงแอป Chat ในพื้นที่ประเภทใดก็ได้ ส่งข้อความที่มีลิงก์ที่ตรงกับรูปแบบ URL สำหรับตัวอย่างลิงก์ พิมพ์ข้อความลงในเมนูแบบเลือกหลายรายการของวิดเจ็ต `selectionInput`	แอป Chat จะตอบกลับตามเนื้อหาของข้อความ เช่น แอป Chat ตอบกลับ ด้วยข้อความ แนบการ์ดตัวอย่างลิงก์ หรือแนะนำรายการใน เมนูแบบเลือกหลายรายการ
นำออกจากพื้นที่ทำงานแล้ว	ผู้ใช้จะนำแอป Chat ออกจากพื้นที่ทำงาน หรือ ผู้ดูแลระบบ Google Workspace จะถอนการติดตั้ง แอป Chat สำหรับผู้ใช้ในองค์กร ผู้ใช้จะนำแอปใน Chat ที่ผู้ดูแลระบบติดตั้งออกไม่ได้ หากผู้ใช้เคยติดตั้งแอป Chat ไว้ก่อนหน้านี้ แอป Chat จะยังคงติดตั้งอยู่ไม่ว่าผู้ดูแลระบบ Google Workspace จะพยายามถอนการติดตั้งหรือไม่ก็ตาม	แอป Chat จะนำการแจ้งเตือนขาเข้าที่กำหนดค่าไว้สำหรับพื้นที่ทำงาน (เช่น การลบ Webhook) และล้างข้อมูลที่จัดเก็บข้อมูลภายใน แอปแชทไม่สามารถตอบกลับด้วยข้อความไปยังทริกเกอร์นี้ได้เนื่องจากไม่ได้เป็นสมาชิกของพื้นที่ทำงานอีกต่อไป
คำสั่งแอป	ผู้ใช้เรียกใช้คำสั่งแอป Chat (เช่น คำสั่งเครื่องหมายทับ คำสั่งด่วน หรือการดำเนินการกับข้อความ)	แอป Chat จะตอบกลับคำสั่ง เช่น ตอบกลับด้วยข้อความหรือเปิดกล่องโต้ตอบ
หน้าแรกของแอป	ผู้ใช้เปิดแท็บหน้าแรกในพื้นที่ข้อความส่วนตัวแบบ 1:1 (DM) ที่มีแอป Chat หรือโต้ตอบกับ วิดเจ็ตใน การ์ดหน้าแรก	แอป Chat จะแสดงออบเจ็กต์ `RenderActions` ที่ส่งการ์ดหน้าแรก (`pushCard`) หรืออัปเดตการ์ดหน้าแรกที่แสดง (`updateCard`)

คุณกำหนดค่าปลายทางหรือฟังก์ชัน Callback สำหรับทริกเกอร์เหล่านี้ได้ใน คอนโซล Google Cloud ในหน้าการกำหนดค่าของ Chat API ดูวิธีการทีละขั้นตอนได้ที่กำหนดค่า Google Chat API

กำหนดค่าพรอมต์เริ่มต้น

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

วิธีเพิ่มและกำหนดค่าพรอมต์เริ่มต้น

ในคอนโซล Google Cloud ให้ไปที่หน้าการกำหนดค่า Chat API โดยทำดังนี้

ไปที่หน้าการกำหนดค่า Chat API
ในส่วนฟีเจอร์แบบอินเทอร์แอกทีฟ ให้ค้นหาพรอมต์เริ่มต้น แล้วคลิกเพิ่มพรอมต์
ในช่องอันดับ (1-3) ให้ป้อนตัวเลขตั้งแต่ 1 ถึง 3 เพื่อระบุลําดับการแสดง
ในส่วนการเลือกประเภท ให้เลือกวิธีที่พรอมต์ทํางาน
- พรอมต์ข้อความ: ป้อนข้อความที่กำหนดไว้ล่วงหน้าลงในช่องสำหรับเขียนเมื่อผู้ใช้คลิกชิปพรอมต์
- Command Prompt: เรียกใช้คำสั่งเครื่องหมายทับหรือคำสั่งด่วนที่ลงทะเบียนไว้เมื่อคลิก คุณเลือกคำสั่งที่ต้องมีอาร์กิวเมนต์เพิ่มเติมไม่ได้
กำหนดค่าพรอมต์ตามประเภทที่คุณเลือก
- หากเลือกพรอมต์ข้อความ ให้ทำดังนี้
  1. ในชื่อ ให้ป้อนชื่อพรอมต์ที่แสดงในชิป (สูงสุด 30 อักขระ)
  2. ในข้อความพรอมต์ ให้ป้อนข้อความที่ป้อนในช่องสำหรับเขียน (ไม่เกิน 60 อักขระ)
  3. ไม่บังคับ: เพิ่มชื่อและข้อความที่แปลเป็นภาษาท้องถิ่นสำหรับผู้ใช้ในภาษาอื่นๆ โดยทำดังนี้
  4. ในส่วนพรอมต์ที่แปลแล้ว ให้คลิกเพิ่มภาษา
  5. ในภาษา ให้เลือกภาษาที่รองรับจากเมนูแบบเลื่อนลง
  6. ในชื่อที่แปลแล้ว ให้ป้อนชื่อที่แปลแล้ว (สูงสุด 30 อักขระ)
  7. ในข้อความพรอมต์ที่แปลแล้ว ให้ป้อนข้อความพรอมต์ที่แปลแล้ว (สูงสุด 60 อักขระ)
  8. ทำซ้ำเพื่อเพิ่มภาษาอื่นๆ ตามต้องการ
- หากคุณเลือก Command Prompt ให้ทำดังนี้
  1. ในคำสั่งเครื่องหมายทับ / คำสั่งด่วน ให้เลือกคำสั่งจากเมนูแบบเลื่อนลง
คลิกเสร็จสิ้น แล้วคลิกบันทึกที่ด้านล่างของหน้า

จัดการการลองใหม่ของการเรียก HTTP ไปยังบริการของคุณ

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

ออบเจ็กต์เหตุการณ์

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

เพย์โหลดของออบเจ็กต์เหตุการณ์

ออบเจ็กต์เหตุการณ์แชทแต่ละรายการจะมี commonEventObject พร้อมรายละเอียดโฮสต์และแพลตฟอร์ม (hostApp: "CHAT", clientPlatform, userLocale, userTimezone, parameters และ formInputs) และออบเจ็กต์ chat ที่มีบริบทเฉพาะของแชท

สำหรับการทริกเกอร์หน้าแรกของแอป (เมื่อผู้ใช้เปิดแท็บหน้าแรกในข้อความส่วนตัวแบบ 1:1 กับแอป Chat) ออบเจ็กต์ chat จะมี chat.user และ chat.eventTime โดยไม่มีฟิลด์ payload เมื่อผู้ใช้คลิกปุ่มในการ์ดหน้าแรก ออบเจ็กต์เหตุการณ์จะมี chat.buttonClickedPayload พร้อมกับ commonEventObject.parameters (และ commonEventObject.formInputs หากการ์ดมีอินพุตแบบฟอร์ม)
สำหรับการโต้ตอบในพื้นที่ทำงานและข้อความ (เพิ่มไปยังพื้นที่ทำงาน ข้อความ นำออกจาก พื้นที่ทำงาน คำสั่งแอป หรือการโต้ตอบกับปุ่มและวิดเจ็ต) ออบเจ็กต์ chat จะมี chat.user, chat.space, chat.eventTime และ เพย์โหลดการโต้ตอบที่เกี่ยวข้อง
- messagePayload: มี space, message และ configCompleteRedirectUri เมื่อผู้ใช้ส่งข้อความ
- addedToSpacePayload: มี space, interactionAdd และ configCompleteRedirectUri เมื่อมีการเพิ่มแอป Chat ลงในพื้นที่
- removedFromSpacePayload: มี space เมื่อ นำแอป Chat ออกจากพื้นที่ทำงาน
- buttonClickedPayload: มี space, message, isDialogEvent และ dialogEventType เมื่อผู้ใช้คลิกปุ่มในการ์ดหรือกล่องโต้ตอบ
- widgetUpdatedPayload: มี space เมื่อผู้ใช้โต้ตอบกับวิดเจ็ต เช่น การพิมพ์ในเมนูแบบหลายตัวเลือกที่มีแหล่งข้อมูลภายนอก
- appCommandPayload: มี space, message, appCommandMetadata, isDialogEvent, dialogEventType และ configCompleteRedirectUri เมื่อผู้ใช้เรียกใช้คำสั่งแอป

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

ส่งคำตอบ

ส่วนนี้อธิบายวิธีที่แอป Chat ใช้การดำเนินการเพื่อตอบสนองต่อการโต้ตอบของผู้ใช้แบบซิงโครนัส

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

หากต้องการตอบสนองต่อการโต้ตอบของผู้ใช้แบบซิงโครนัส แอป Chat จะจัดการออบเจ็กต์เหตุการณ์ขาเข้าและส่งคืนออบเจ็กต์ JSON อย่างใดอย่างหนึ่งต่อไปนี้

DataActions: สร้างหรืออัปเดต ข้อความแชท (CreateMessageAction, UpdateMessageAction) หรือ แนบตัวอย่างลิงก์ (UpdateInlinePreviewAction) โดยใช้ chatDataActionMarkup
RenderActions: สร้าง อัปเดต หรือ ปิดหน้าแรกหรือ กล่องโต้ตอบ (pushCard, updateCard, endNavigation: "CLOSE_DIALOG") หรือให้คำแนะนำการป้อนข้อมูลแบบไดนามิกสำหรับเมนูแบบเลือกหลายรายการ (modifyCard)
AuthorizationError: แจ้งผู้ใช้ด้วยการ์ดการให้สิทธิ์พื้นฐาน (basic_authorization_prompt) เพื่อลงชื่อเข้าใช้หรือตรวจสอบสิทธิ์กับบริการภายนอก

ตารางต่อไปนี้แสดงวิธีที่แอป Chat ตอบกลับด้วย การดำเนินการ แอปใน Chat สามารถส่งคืนออบเจ็กต์ JSON โดยตรงหรือสร้างการตอบกลับโดยใช้ AddOnResponseService และ CardService ของ Apps Script

การตอบกลับของแอปแชท	การดำเนินการที่จำเป็นในการคืนสินค้า (JSON)	การดำเนินการที่จำเป็นในการส่งคืน (Apps Script)
ส่งข้อความหรืออัปเดตข้อความ	`DataActions` (`createMessageAction` หรือ `updateMessageAction`)	`DataActionsResponse`
ดูตัวอย่างลิงก์ในข้อความที่ผู้ใช้ Chat ส่งในพื้นที่ทำงาน	`DataActions` (`updateInlinePreviewAction`)	`DataActionsResponse`
แสดงผลหรืออัปเดตหน้าแรกในแท็บหน้าแรกของข้อความส่วนตัว	`RenderActions` (`pushCard` หรือ `updateCard`)	`ActionResponse`
เปิด อัปเดต หรือปิดกล่องโต้ตอบ	`RenderActions` (`pushCard`, `updateCard` หรือ `endNavigation: "CLOSE_DIALOG"`)	`ActionResponse`
หากต้องการรวบรวมข้อมูลจากการ์ดหรือกล่องโต้ตอบ ให้แนะนำรายการที่เลือกตามสิ่งที่ผู้ใช้พิมพ์ลงในเมนูแบบเลือกหลายรายการ	`RenderActions` (`modifyCard`)	`ActionResponse`
ขอการกำหนดค่าหรือการให้สิทธิ์สำหรับบริการภายนอก	`AuthorizationError` (`basic_authorization_prompt`)	`AuthorizationException`

ตอบกลับด้วยข้อความ

แอปใน Chat สามารถตอบกลับด้วยข้อความไปยังทริกเกอร์หรือการโต้ตอบต่อไปนี้

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

แอปแชทสามารถรวมสิ่งต่อไปนี้ไว้ในข้อความ

ข้อความที่มีไฮเปอร์ลิงก์, @mention และอีโมจิ ดูจัดรูปแบบข้อความ
การ์ดอย่างน้อย 1 ใบซึ่งอาจปรากฏในข้อความหรือเปิดในหน้าต่างใหม่เป็นกล่องโต้ตอบ ดูสร้างการ์ดสำหรับแอป Google Chat
วิดเจ็ตอุปกรณ์เสริมอย่างน้อย 1 รายการ ซึ่งเป็นปุ่มที่ปรากฏหลังจากข้อความ หรือการ์ดในข้อความ

หากต้องการตอบกลับด้วยข้อความ ให้ส่งคืน DataActions พร้อมออบเจ็กต์ CreateMessageAction ดังนี้

{
  "hostAppDataAction": {
    "chatDataAction": {
      "createMessageAction": {
        "message": <var>MESSAGE</var>
      }
    }
  }
}

แทนที่ MESSAGE ด้วย Message ทรัพยากรจาก Chat API

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

Node.js

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} req The request object from Google Chat.
 * @param {Object} res The response object from the Chat app.
 */
exports.cymbalApp = function cymbalApp(req, res) {
  const chatEvent = req.body.chat;
  // Send an onboarding message when added to a Chat space
  if (chatEvent.addedToSpacePayload) {
    res.json({ hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
      text: 'Hi, Cymbal at your service. I help you manage your calendar ' +
        'from Google Chat. Take a look at your schedule today by typing ' +
        '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. ' +
        'To learn what else I can do, type `/help`.'
    }}}}});
  }
};

Python

from flask import Flask, request, json
app = Flask(__name__)

@app.route('/', methods=['POST'])
def cymbal_app():
  """Sends an onboarding message when the Chat app is added to a space.

  Returns:
    Mapping[str, Any]: The response object from the Chat app.
  """
  chat_event = request.get_json()["chat"]
  if "addedToSpacePayload" in chat_event:
    return json.jsonify({ "hostAppDataAction": { "chatDataAction": {
      "createMessageAction": { "message": {
        "text": 'Hi, Cymbal at your service. I help you manage your calendar ' +
        'from Google Chat. Take a look at your schedule today by typing ' +
        '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. ' +
        'To learn what else I can do, type `/help`.'
      }}
    }}})

Java

@SpringBootApplication
@RestController
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }

  /*
   * Sends an onboarding message when the Chat app is added to a space.
   *
   * @return The response object from the Chat app.
   */
  @PostMapping("/")
  @ResponseBody
  public GenericJson onEvent(@RequestBody JsonNode event) throws Exception {
    JsonNode chatEvent = event.at("/chat");
    if (!chatEvent.at("/addedToSpacePayload").isEmpty()) {
      return new GenericJson() { {
        put("hostAppDataAction", new GenericJson() { {
          put("chatDataAction", new GenericJson() { {
            put("createMessageAction", new GenericJson() { {
              put("message", new Message().setText(
                "Hi, Cymbal at your service. I help you manage your calendar " +
                "from Google Chat. Take a look at your schedule today by typing " +
                "`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. " +
                "To learn what else I can do, type `/help`."
              ));
            } });
          } });
        } });
      } };
    }
    return new GenericJson();
  }
}

Apps Script

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} event The event object from Google Chat.
 * @return {Object} Response from the Chat app.
 */
function onAddedToSpace(event) {
  return { hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
    text: 'Hi, Cymbal at your service. I help you manage your calendar ' +
          'from Google Chat. Take a look at your schedule today by typing ' +
          '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. ' +
          'To learn what else I can do, type `/help`.'
  }}}}};
}

ตัวอย่างโค้ดจะแสดงผลข้อความต่อไปนี้

ตัวอย่างข้อความเริ่มต้นใช้งาน

อัปเดตข้อความ

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

หากต้องการอัปเดตข้อความแอป Chat เพื่อตอบสนองต่อการโต้ตอบ ให้ส่งคืน DataActions พร้อมด้วย UpdateMessageAction

{
  "hostAppDataAction": {
    "chatDataAction": {
      "updateMessageAction": {
        "message": <var>MESSAGE</var>
      }
    }
  }
}

แทนที่ MESSAGE ด้วย Message ทรัพยากรจาก Chat API

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

ตอบแบบไม่พร้อมกันโดยใช้ Google Chat API

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

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

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

Node.js

async function onEvent(req, res) {
  // Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return res.send({});
};

Python

def on_event(event) -> dict:
  # Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return {}

Java

public String onEvent(JsonNode event) {
  // Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return "{}";
}

Apps Script

function onEvent(event) {
  // Trigger asynchronous job that will respond using the Google Chat API.
  ...

  // Respond with an empty response to the Google Chat platform.
  return null;
}

หากต้องการส่งข้อความโดยใช้ Chat API ให้ตั้งค่าการตรวจสอบสิทธิ์และเรียกใช้เมธอด spaces.messages.create ดูขั้นตอนได้ที่ส่งข้อความ ดูคำแนะนำเกี่ยวกับการใช้ เมธอด Chat API อื่นๆ ได้ที่ ภาพรวมของ Chat API

แอป Chat ที่ไม่ใช่ส่วนเสริม: รับและตอบสนองต่อการโต้ตอบของผู้ใช้

แอป Chat ที่ไม่ใช่ส่วนเสริมของ Google Workspace จะได้รับ เหตุการณ์การโต้ตอบของ Chat API (Event) แทน ออบเจ็กต์เหตุการณ์ส่วนเสริมของ Google Workspace (EventObject) และตอบกลับโดยการแสดงผลทรัพยากร Message แทนการดำเนินการ

หากต้องการอัปเกรดแอป Chat ที่ไม่ใช่ส่วนเสริมเป็นเฟรมเวิร์กส่วนเสริมของ Google Workspace โปรดดูหัวข้อแปลงแอป Google Chat เป็นส่วนเสริมของ Google Workspace

ประเภทของเหตุการณ์การโต้ตอบ

สำหรับการโต้ตอบของผู้ใช้แต่ละประเภท Google Chat จะส่ง แอป Chat ที่ไม่ใช่ส่วนเสริม Eventออบเจ็กต์ที่มีประเภทซึ่งแสดงโดยฟิลด์ eventType ดังนี้

การโต้ตอบของผู้ใช้	`eventType`	การตอบกลับโดยทั่วไปจากแอป Chat ที่ไม่ใช่ส่วนเสริม
ผู้ใช้ส่งข้อความถึงแอป Chat เช่น @พูดถึงแอป Chat หรือใช้คำสั่งเครื่องหมายทับ	`MESSAGE`	แอป Chat จะตอบกลับตามเนื้อหาของข้อความ เช่น แอป Chat จะตอบกลับ คำสั่งเครื่องหมายทับ `/about` ด้วยข้อความที่อธิบายงาน ที่แอป Chat ทำได้
ผู้ใช้เพิ่มแอปใน Chat ลงในพื้นที่ทำงาน	`ADDED_TO_SPACE`	แอป Chat จะส่งข้อความเริ่มต้นใช้งาน ที่อธิบายสิ่งที่แอปทำและวิธีที่ผู้ใช้ในพื้นที่ทำงานโต้ตอบกับแอป
ผู้ใช้นำแอป Chat ออกจากพื้นที่ทำงาน	`REMOVED_FROM_SPACE`	แอป Chat จะนำการแจ้งเตือนขาเข้าที่กำหนดค่าไว้สำหรับพื้นที่ทำงาน (เช่น การลบ Webhook) และล้างข้อมูลที่จัดเก็บข้อมูลภายใน
ผู้ใช้คลิกปุ่มในการ์ดจาก ข้อความ กล่องโต้ตอบ หรือหน้าแรกของแอป Chat	`CARD_CLICKED`	แอป Chat จะประมวลผลและจัดเก็บข้อมูลใดๆ ที่ผู้ใช้ส่งมา หรือแสดงการ์ดอื่น
ผู้ใช้เปิดหน้าแรกของแอป Chat โดยคลิกแท็บหน้าแรก ในข้อความแบบ 1:1	`APP_HOME`	แอป Chat จะแสดงการ์ดแบบคงที่หรือแบบอินเทอร์แอกทีฟ จากหน้าแรก
ผู้ใช้ส่งแบบฟอร์มจากหน้าแรกของแอป Chat	`SUBMIT_FORM`	แอป Chat จะประมวลผลและจัดเก็บข้อมูลใดๆ ที่ผู้ใช้ส่งมา หรือแสดงการ์ดอื่น
ผู้ใช้เรียกใช้คำสั่งโดยใช้คำสั่งด่วน	`APP_COMMAND`	แอป Chat จะตอบกลับตามคำสั่งที่เรียกใช้ เช่น แอป Chat จะตอบกลับคำสั่งเกี่ยวกับด้วยข้อความที่อธิบายงานที่แอป Chat ทำได้

หากต้องการดูเหตุการณ์การโต้ตอบที่รองรับทั้งหมดและตัวอย่างเพย์โหลด JSON โปรดดู ประเภทของเหตุการณ์การโต้ตอบของแอป Chat และ เอกสารอ้างอิงEventType

เหตุการณ์การโต้ตอบจากกล่องโต้ตอบ

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

ฟิลด์ isDialogEvent ตั้งค่าเป็น true
DialogEventType (REQUEST_DIALOG, SUBMIT_DIALOG หรือ CANCEL_DIALOG) จะระบุว่าการโต้ตอบจะทริกเกอร์ให้เปิดกล่องโต้ตอบ ส่งข้อมูลจากกล่องโต้ตอบ หรือปิดกล่องโต้ตอบ

กำหนดค่าแอป Chat ที่ไม่ใช่ส่วนเสริมเพื่อรับเหตุการณ์การโต้ตอบ

ในคอนโซล Google Cloud ให้ไปที่หน้าการกำหนดค่า ของ Chat API

ไปที่หน้าการกำหนดค่า Chat API
ในส่วนฟีเจอร์แบบอินเทอร์แอกทีฟ ให้ยกเลิกการเลือกสร้างแอปแชทนี้เป็นส่วนเสริมของ Google Workspace และ กำหนดค่าฟังก์ชันการทำงาน, จุดสิ้นสุดการตั้งค่าการเชื่อมต่อเดียว (URL ของจุดสิ้นสุด HTTP, Apps Script, ชื่อหัวข้อ Cloud Pub/Sub หรือ Dialogflow), คำสั่ง, พรอมต์เริ่มต้น, ตัวอย่างลิงก์ และ ระดับการมองเห็น
คลิกบันทึก

ตอบกลับด้วยข้อความในแอป Chat ที่ไม่ใช่ส่วนเสริม

หากต้องการตอบกลับแบบซิงโครนัสในแอป Chat ที่ไม่ใช่ ส่วนเสริม ให้ส่งคืนออบเจ็กต์ Message โดยตรง ตัวอย่างต่อไปนี้ตอบกลับเหตุการณ์ADDED_TO_SPACE การโต้ตอบด้วยข้อความ

Node.js

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} req The event object from Chat API.
 * @param {Object} res The response object from the Chat app.
 */
exports.cymbalApp = function cymbalApp(req, res) {
  // Send an onboarding message when added to a Chat space
  if (req.body.type === 'ADDED_TO_SPACE') {
    res.json({
      'text': 'Hi, Cymbal at your service. I help you manage your calendar ' +
        'from Google Chat. Take a look at your schedule today by typing ' +
        '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. To ' +
        'learn what else I can do, type `/help`.'
    });
  }
};

Python

from flask import Flask, request, json
app = Flask(__name__)

@app.route('/', methods=['POST'])
def cymbal_app():
  """Sends an onboarding message when the Chat app is added to a space.

  Returns:
    Mapping[str, Any]: The response object from the Chat app.
  """
  event = request.get_json()
  if event['type'] == 'ADDED_TO_SPACE':
    return json.jsonify({
      'text': 'Hi, Cymbal at your service. I help you manage your calendar ' +
      'from Google Chat. Take a look at your schedule today by typing ' +
      '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. To ' +
      'learn what else I can do, type `/help`.'
    })
  return json.jsonify({})

Java

@SpringBootApplication
@RestController
public class App {
  public static void main(String[] args) {
    SpringApplication.run(App.class, args);
  }

  /*
   * Sends an onboarding message when the Chat app is added to a space.
   *
   * @return The response object from the Chat app.
   */
  @PostMapping("/")
  @ResponseBody
  public Message onEvent(@RequestBody JsonNode event) {
    switch (event.get("type").asText()) {
      case "ADDED_TO_SPACE":
        return new Message().setText(
          "Hi, Cymbal at your service. I help you manage your calendar " +
          "from Google Chat. Take a look at your schedule today by typing " +
          "`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. " +
          "To learn what else I can do, type `/help`.");
      default:
        return new Message();
    }
  }
}

Apps Script

/**
 * Sends an onboarding message when the Chat app is added to a space.
 *
 * @param {Object} event The event object from Chat API.
 * @return {Object} Response from the Chat app.
 */
function onAddToSpace(event) {
  return {
    'text': 'Hi, Cymbal at your service. I help you manage your calendar ' +
      'from Google Chat. Take a look at your schedule today by typing ' +
      '`/checkCalendar`, or schedule a meeting with `/scheduleMeeting`. To learn ' +
      'what else I can do, type `/help`.'
  };
}

ข้อกำหนดเบื้องต้น

วิธีการทำงานของการโต้ตอบของผู้ใช้

ทริกเกอร์

กำหนดค่าพรอมต์เริ่มต้น

จัดการการลองใหม่ของการเรียก HTTP ไปยังบริการของคุณ

ออบเจ็กต์เหตุการณ์

เพย์โหลดของออบเจ็กต์เหตุการณ์

ส่งคำตอบ

ตอบกลับด้วยข้อความ

Node.js

Python

Java

Apps Script

อัปเดตข้อความ

ตอบแบบไม่พร้อมกันโดยใช้ Google Chat API

Node.js

Python

Java

Apps Script

หัวข้อที่เกี่ยวข้อง

แอป Chat ที่ไม่ใช่ส่วนเสริม: รับและตอบสนองต่อการโต้ตอบของผู้ใช้

ประเภทของเหตุการณ์การโต้ตอบ

เหตุการณ์การโต้ตอบจากกล่องโต้ตอบ

กำหนดค่าแอป Chat ที่ไม่ใช่ส่วนเสริมเพื่อรับเหตุการณ์การโต้ตอบ

ตอบกลับด้วยข้อความในแอป Chat ที่ไม่ใช่ส่วนเสริม

Node.js

Python

Java

Apps Script