สังเกตกิจกรรมการประชุมด้วย Python และ Google Meet REST API

บทแนะนำนี้แสดงวิธีใช้ Google Meet REST API ร่วมกับ Google Workspace Events API และ Google Cloud Pub/Sub เพื่อสังเกตและตอบสนองต่อเหตุการณ์ในพื้นที่การประชุม Meet แอปพลิเคชันตัวอย่างจะบันทึกเมื่อการประชุมเริ่มและสิ้นสุด เมื่อผู้เข้าร่วมเข้าร่วมหรือออกจากการประชุม และเมื่ออาร์ติแฟกต์การประชุมที่สร้างขึ้นพร้อมใช้งาน

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

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

หากต้องการเปิดใช้ข้อกำหนดเบื้องต้นเหล่านี้สำหรับองค์กร โปรดขอให้ ผู้ดูแลระบบ Google Workspace เปิดใช้

• บัญชี Google Workspace ที่มีสิทธิ์เข้าถึง Google Meet
• สิทธิ์เข้าถึงเพื่อสร้างโปรเจ็กต์ Google Cloud
• ติดตั้ง Python 3 แล้ว
• ติดตั้ง gcloud CLI แล้ว

เตรียมสภาพแวดล้อม

ส่วนนี้จะแสดงวิธีสร้างและกำหนดค่าสภาพแวดล้อมในเครื่องและโปรเจ็กต์ที่อยู่ในระบบคลาวด์ Google Cloud สำหรับบทแนะนำนี้

สร้างไดเรกทอรีการทำงานและสภาพแวดล้อมเสมือนของ Python

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

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
source env/bin/activate

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
env/bin/activate.bat

mkdir meet-tutorial
cd meet-tutorial
python3 -mvenv env
env/bin/activate.ps1

สร้างโปรเจ็กต์ Google Cloud

เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google

ตั้งค่าการตรวจสอบสิทธิ์และการให้สิทธิ์

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

กำหนดค่าหน้าจอขอความยินยอม OAuth และเลือกขอบเขต

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

1. ใน Google API Console ให้ไปที่เมนู menu > แพลตฟอร์มการตรวจสอบสิทธิ์ของ Google > การสร้างแบรนด์

   ไปที่การสร้างแบรนด์

2. หากกำหนดค่าแพลตฟอร์มการตรวจสอบสิทธิ์ของ Google แล้ว คุณจะกำหนดค่าการตั้งค่าหน้าจอขอคำยินยอม OAuth ต่อไปนี้ได้ในการสร้างแบรนด์ กลุ่มเป้าหมาย และการเข้าถึงข้อมูล หากเห็นข้อความที่ระบุว่ายังไม่ได้กำหนดค่าแพลตฟอร์ม Google Auth ให้คลิกเริ่มต้นใช้งาน
1. ในส่วนข้อมูลแอป ให้ป้อน Meet REST API Tutorial ในชื่อแอป
2. ในอีเมลสนับสนุนสำหรับผู้ใช้ ให้เลือกอีเมลสนับสนุนที่ผู้ใช้สามารถติดต่อคุณได้หากมีข้อสงสัยเกี่ยวกับการยินยอม
3. คลิกถัดไป
4. ในส่วนกลุ่มเป้าหมาย ให้เลือกภายใน
5. คลิกถัดไป
6. ในส่วนข้อมูลติดต่อ ให้ป้อนอีเมลที่คุณต้องการรับการแจ้งเตือนเกี่ยวกับการเปลี่ยนแปลงในโปรเจ็กต์
7. คลิกถัดไป
8. ในส่วนเสร็จสิ้น ให้อ่านนโยบายข้อมูลผู้ใช้ของบริการ Google API และหากยอมรับ ให้เลือกฉันยอมรับบริการ Google API: นโยบายข้อมูลผู้ใช้
9. คลิกต่อไป
10. คลิกสร้าง
11. หากเลือกภายนอกสำหรับประเภทผู้ใช้ ให้เพิ่มผู้ใช้ทดสอบโดยทำดังนี้
    1. คลิกกลุ่มเป้าหมาย
    2. ในส่วนผู้ใช้ทดสอบ ให้คลิกเพิ่มผู้ใช้
    3. ป้อนอีเมลของคุณและผู้ใช้ทดสอบที่ได้รับอนุญาตอื่นๆ แล้วคลิกบันทึก
3. คลิกการเข้าถึงข้อมูล > เพิ่มหรือนำขอบเขตออก แผงจะปรากฏขึ้นพร้อมรายการขอบเขต สำหรับ API แต่ละรายการที่คุณเปิดใช้ในโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google
4. ในส่วนเพิ่มขอบเขตด้วยตนเอง ให้วางขอบเขตต่อไปนี้
   • https://www.googleapis.com/auth/meetings.space.created
5. คลิกเพิ่มลงในตาราง
6. คลิกอัปเดต
7. หลังจากเลือกขอบเขตที่แอปของคุณต้องการแล้ว ให้คลิกบันทึก

ดูข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่าความยินยอม OAuth ได้ที่ เริ่มต้นใช้งานแพลตฟอร์ม Google Auth

สร้างรหัสไคลเอ็นต์

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

1. ใน Google API Console ให้ไปที่เมนู menu > แพลตฟอร์มการตรวจสอบสิทธิ์ของ Google > ไคลเอ็นต์

   ไปที่ไคลเอ็นต์

2. คลิกสร้างไคลเอ็นต์
3. คลิกประเภทแอปพลิเคชัน > แอปเดสก์ท็อป
4. ในช่องชื่อ ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้จะแสดงในคอนโซล Google API เท่านั้น
5. คลิกสร้าง

   ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วน "รหัสไคลเอ็นต์ OAuth 2.0"

ติดตั้งไลบรารีการตรวจสอบสิทธิ์ของ Google

ติดตั้งไลบรารีการตรวจสอบสิทธิ์ของ Google โดยทำดังนี้

pip install google-auth google-auth-oauthlib

ดำเนินการให้สิทธิ์

Meet REST API ต้องใช้ข้อมูลเข้าสู่ระบบของผู้ใช้ในรูปแบบโทเค็นเพื่อการเข้าถึง OAuth 2.0 ในส่วนนี้ คุณจะใช้ขั้นตอน OAuth 2.0 เพื่อขอโทเค็นเพื่อการเข้าถึงและโทเค็นรีเฟรชสำหรับผู้ใช้

1. สร้างไฟล์ main.py ในไดเรกทอรีที่ทำงานอยู่ แล้วเพิ่มเนื้อหาต่อไปนี้

   import os
   import json
   
   from google.auth.transport import requests
   from google.oauth2.credentials import Credentials
   from google_auth_oauthlib.flow import InstalledAppFlow
   
   def authorize() -> Credentials:
       """Ensure valid credentials for calling the Meet REST API."""
       CLIENT_SECRET_FILE = "./client_secret.json"
       credentials = None
   
       if os.path.exists('token.json'):
           credentials = Credentials.from_authorized_user_file('token.json')
   
       if credentials is None:
           flow = InstalledAppFlow.from_client_secrets_file(
               CLIENT_SECRET_FILE,
               scopes=[
                   'https://www.googleapis.com/auth/meetings.space.created',
               ])
           flow.run_local_server(port=0)
           credentials = flow.credentials
   
       if credentials and credentials.expired:
           credentials.refresh(requests.Request())
   
       if credentials is not None:
           with open("token.json", "w") as f:
               f.write(credentials.to_json())
   
       return credentials
   
   USER_CREDENTIALS = authorize()
   

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

3. หากต้องการทดสอบการทำงานของการให้สิทธิ์ ให้เรียกใช้คำสั่งต่อไปนี้ แอปจะแจ้งให้ขอสิทธิ์และสร้างไฟล์ token.json ใน ไดเรกทอรีการทำงานของโปรเจ็กต์หลังจากที่คำขอได้รับการอนุมัติ

   python3 main.py

เพิ่ม REST API ของ Meet

เมื่อรหัสการให้สิทธิ์พร้อมแล้ว ก็ถึงเวลาเปิดใช้และเรียกใช้ Meet REST API

เปิดใช้ API

แม้ว่าส่วนนี้จะมุ่งเน้นที่ Meet REST API แต่บทแนะนำนี้ยังใช้ Google Cloud Pub/Sub และ Google Workspace Events API ด้วย

ติดตั้งไลบรารีของไคลเอ็นต์ Meet REST API

ทำตามขั้นตอนต่อไปนี้เพื่อติดตั้งไลบรารีของไคลเอ็นต์ Meet REST API

1. เรียกใช้คำสั่งต่อไปนี้

   pip install google-apps-meet

2. แก้ไขไฟล์ main.py เพื่อนำเข้าไคลเอ็นต์โดยทำดังนี้

   from google.apps import meet_v2 as meet
   

สร้างพื้นที่ทำงาน

ตอนนี้ Meet REST API พร้อมใช้งานแล้ว ให้กำหนดฟังก์ชันเพื่อสร้างพื้นที่การประชุมที่สามารถติดตามได้

แก้ไข main.py และเพิ่มข้อมูลต่อไปนี้

def create_space() -> meet.Space:
    """Create a meeting space."""
    client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
    request = meet.CreateSpaceRequest()
    return client.create_space(request=request)

สมัครรับข้อมูลกิจกรรม

หากต้องการรับกิจกรรมเกี่ยวกับพื้นที่การประชุม คุณต้องสร้างการสมัครใช้บริการโดยใช้ Google Workspace Events API นอกจากนี้ คุณยังต้องสร้างและสมัครใช้หัวข้อ Google Cloud Pub/Sub ซึ่งทำหน้าที่เป็นปลายทางการแจ้งเตือนที่แอปของคุณได้รับเหตุการณ์ด้วย

กำหนดค่า Google Cloud Pub/Sub

วิธีสร้างและสมัครใช้บริการหัวข้อ Pub/Sub

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

สร้างบัญชีบริการ

ใช้บัญชีบริการ

หลังจากสร้างบัญชีบริการแล้ว ให้สิทธิ์ตัวเองในการแอบอ้างเป็นบัญชีบริการ

ติดตั้งไลบรารีของไคลเอ็นต์ Pub/Sub

1. ใช้ pip เพื่อติดตั้งไลบรารีของไคลเอ็นต์สำหรับ Pub/Sub

   pip install google-cloud-pubsub

2. จากนั้นแก้ไข main.py เพื่อนำเข้าไคลเอ็นต์โดยทำดังนี้

   from google.cloud import pubsub_v1
   

สร้างการสมัครใช้บริการ Google Workspace

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

def subscribe_to_space(space_name: str = None, topic_name: str = None):
    """Subscribe to events for a meeting space."""
    session = requests.AuthorizedSession(USER_CREDENTIALS)
    body = {
        'targetResource': f"//meet.googleapis.com/{space_name}",
        "eventTypes": [
            "google.workspace.meet.conference.v2.started",
            "google.workspace.meet.conference.v2.ended",
            "google.workspace.meet.participant.v2.joined",
            "google.workspace.meet.participant.v2.left",
            "google.workspace.meet.recording.v2.fileGenerated",
            "google.workspace.meet.transcript.v2.fileGenerated",
        ],
        "payloadOptions": {
            "includeResource": False,
        },
        "notificationEndpoint": {
            "pubsubTopic": topic_name
        },
        "ttl": "86400s",
    }
    response = session.post("https://workspaceevents.googleapis.com/v1/subscriptions", json=body)
    return response

จากนั้นเพิ่มโค้ดที่เกี่ยวข้องเพื่อดึงและประมวลผลเหตุการณ์

ฟังและจัดการเหตุการณ์

แก้ไข main.py ต่อไปและเพิ่มโค้ดตัวอย่างต่อไปนี้ โค้ดนี้ ใช้ฝั่งรับและใช้ Google Cloud Pub/Sub API เพื่อดึง เหตุการณ์เมื่อพร้อมใช้งาน เมธอดตัวแฮนเดิลต่างๆ จะพิมพ์ข้อมูล เกี่ยวกับเหตุการณ์ที่เกี่ยวข้อง

def format_participant(participant: meet.Participant) -> str:
    """Formats a participant for display on the console."""
    if participant.anonymous_user:
        return f"{participant.anonymous_user.display_name} (Anonymous)"

    if participant.signedin_user:
        return f"{participant.signedin_user.display_name} (ID: {participant.signedin_user.user})"

    if participant.phone_user:
        return f"{participant.phone_user.display_name} (Phone)"

    return "Unknown participant"


def fetch_participant_from_session(session_name: str) -> meet.Participant:
    """Fetches the participant for a session."""
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    # Use the parent path of the session to fetch the participant details
    parsed_session_path = client.parse_participant_session_path(session_name)
    participant_resource_name = client.participant_path(
        parsed_session_path["conference_record"],
        parsed_session_path["participant"])
    return client.get_participant(name=participant_resource_name)


def on_conference_started(message: pubsub_v1.subscriber.message.Message):
    """Display information about a conference when started."""
    payload = json.loads(message.data)
    resource_name = payload.get("conferenceRecord").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    conference = client.get_conference_record(name=resource_name)
    print(f"Conference (ID {conference.name}) started at {conference.start_time.rfc3339()}")


def on_conference_ended(message: pubsub_v1.subscriber.message.Message):
    """Display information about a conference when ended."""
    payload = json.loads(message.data)
    resource_name = payload.get("conferenceRecord").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    conference = client.get_conference_record(name=resource_name)
    print(f"Conference (ID {conference.name}) ended at {conference.end_time.rfc3339()}")


def on_participant_joined(message: pubsub_v1.subscriber.message.Message):
    """Display information about a participant when they join a meeting."""
    payload = json.loads(message.data)
    resource_name = payload.get("participantSession").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    session = client.get_participant_session(name=resource_name)
    participant = fetch_participant_from_session(resource_name)
    display_name = format_participant(participant)
    print(f"{display_name} joined at {session.start_time.rfc3339()}")


def on_participant_left(message: pubsub_v1.subscriber.message.Message):
    """Display information about a participant when they leave a meeting."""
    payload = json.loads(message.data)
    resource_name = payload.get("participantSession").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    session = client.get_participant_session(name=resource_name)
    participant = fetch_participant_from_session(resource_name)
    display_name = format_participant(participant)
    print(f"{display_name} left at {session.end_time.rfc3339()}")


def on_recording_ready(message: pubsub_v1.subscriber.message.Message):
    """Display information about a recorded meeting when artifact is ready."""
    payload = json.loads(message.data)
    resource_name = payload.get("recording").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    recording = client.get_recording(name=resource_name)
    print(f"Recording available at {recording.drive_destination.export_uri}")


def on_transcript_ready(message: pubsub_v1.subscriber.message.Message):
    """Display information about a meeting transcript when artifact is ready."""
    payload = json.loads(message.data)
    resource_name = payload.get("transcript").get("name")
    client = meet.ConferenceRecordsServiceClient(credentials=USER_CREDENTIALS)
    transcript = client.get_transcript(name=resource_name)
    print(f"Transcript available at {transcript.docs_destination.export_uri}")


def on_message(message: pubsub_v1.subscriber.message.Message) -> None:
    """Handles an incoming event from the Google Cloud Pub/Sub API."""
    event_type = message.attributes.get("ce-type")
    handler = {
        "google.workspace.meet.conference.v2.started": on_conference_started,
        "google.workspace.meet.conference.v2.ended": on_conference_ended,
        "google.workspace.meet.participant.v2.joined": on_participant_joined,
        "google.workspace.meet.participant.v2.left": on_participant_left,
        "google.workspace.meet.recording.v2.fileGenerated": on_recording_ready,
        "google.workspace.meet.transcript.v2.fileGenerated": on_transcript_ready,
    }.get(event_type)

    try:
        if handler is not None:
            handler(message)
        message.ack()
    except Exception as error:
        print("Unable to process event")
        print(error)


def listen_for_events(subscription_name: str = None):
    """Subscribe to events on the subscription."""
    subscriber = pubsub_v1.SubscriberClient()
    with subscriber:
        future = subscriber.subscribe(subscription_name, callback=on_message)
        print("Listening for events")
        try:
            future.result()
        except KeyboardInterrupt:
            future.cancel()
    print("Done")

เขียนโค้ดให้เสร็จสมบูรณ์

เพิ่มโค้ดต่อไปนี้ลงใน main.py เพื่อเรียกใช้เมธอดในการสร้างพื้นที่ ติดตามกิจกรรม และฟัง อัปเดตค่าคงที่ TOPIC_NAME และ SUBSCRIPTION_NAME ด้วยชื่อหัวข้อ และการสมัครใช้บริการของคุณเองที่คุณสร้างไว้ก่อนหน้านี้

1. เพิ่มโค้ดไปยัง main.py

   space = create_space()
   print(f"Join the meeting at {space.meeting_uri}")
   
   TOPIC_NAME = "projects/PROJECT_ID/topics/TOPIC_ID"
   SUBSCRIPTION_NAME = "projects/PROJECT_ID/subscriptions/SUBSCRIPTION_ID"
   
   subscription = subscribe_to_space(topic_name=TOPIC_NAME, space_name=space.name)
   if (subscription.status_code) == 200:
       listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   else:
       print(f"Subscription to Meet events failed, response data: {subscription.content}")
   

   แทนที่ค่าต่อไปนี้

   • PROJECT_ID: รหัสโปรเจ็กต์ Cloud ที่ไม่ซ้ำกันสำหรับ แอปของคุณ เช่น my-sample-project-191923

   • TOPIC_ID: ชื่อของหัวข้อ Pub/Sub ที่คุณสร้างในโปรเจ็กต์ที่อยู่ในระบบคลาวด์

   • SUBSCRIPTION_ID: ชื่อการสมัครใช้บริการ เช่น workspace-events-sub

2. เรียกใช้โปรแกรม

   python3 main.py

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

Join the meeting at https://meet.google.com/abc-mnop-xyz

เข้าร่วมการประชุม

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

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

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

ใช้ ctrl-c เพื่อหยุดโปรแกรมเมื่อเสร็จแล้ว

ไม่บังคับ: ขั้นตอนเพิ่มเติมที่ลองทำได้

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

• ใช้ People API เพื่อดึงข้อมูลเพิ่มเติมเกี่ยวกับ ผู้เข้าร่วมที่ลงชื่อเข้าใช้

  def subscribe_to_user(user_name: str = None, topic_name: str = None) -> requests_lib.Response:
      """Subscribe to events for a user."""
      session = requests.AuthorizedSession(USER_CREDENTIALS)
      body = {
          "targetResource": f"//cloudidentity.googleapis.com/users/{user_name}",
          "eventTypes": [
              "google.workspace.meet.conference.v2.started",
              "google.workspace.meet.conference.v2.ended",
              "google.workspace.meet.participant.v2.joined",
              "google.workspace.meet.participant.v2.left",
              "google.workspace.meet.recording.v2.fileGenerated",
              "google.workspace.meet.transcript.v2.fileGenerated",
          ],
          "payloadOptions": {
              "includeResource": False,
          },
          "notificationEndpoint": {"pubsubTopic": topic_name},
          "ttl": "86400s",
      }
      response = session.post(
          "https://workspaceevents.googleapis.com/v1/subscriptions", json=body
      )
      return response
  
  service = build("people", "v1", credentials=USER_CREDENTIALS)
  response = (
      service.people()
      .get(resourceName="people/me", personFields="names,emailAddresses")
      .execute()
  )
  resource_name = response.get("resourceName")
  if resource_name.startswith("people/"):
      resource_name = resource_name[len("people/") :]
  
  subscription = subscribe_to_user(topic_name=TOPIC_NAME, user_name=resource_name)
  

  อย่าลืมเพิ่ม "https://www.googleapis.com/auth/userinfo.profile" ในเมธอด authorize ในตัวอย่างข้อมูลเข้าสู่ระบบด้านบน

• ใช้ Google Drive API เพื่อดาวน์โหลดไฟล์บันทึก และข้อความถอดเสียง

• แทนที่จะดาวน์โหลดข้อความถอดเสียงจาก Google ไดรฟ์ ให้เรียกข้อมูลโดยใช้วิธีการถอดเสียงที่มีโครงสร้าง ใน Meet REST API

• รับพื้นที่แทนการสร้างพื้นที่

  def get_space(meeting_code: str) -> meet.Space:
      """Get a meeting space."""
      client = meet.SpacesServiceClient(credentials=USER_CREDENTIALS)
      return client.get_space(name="spaces/" + meeting_code)
  

  อย่าลืมเพิ่ม "https://www.googleapis.com/auth/meetings.space.readonly" ในเมธอดให้สิทธิ์ในตัวอย่างข้อมูลเข้าสู่ระบบด้านบน

ไม่บังคับ: ล้างข้อมูล

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

วิธีลบการสมัครใช้บริการ

วิธีลบหัวข้อ

วิธีลบโปรเจ็กต์

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

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