Mengamati acara rapat dengan Python dan REST API Google Meet

Tutorial ini menunjukkan cara menggunakan Google Meet REST API bersama dengan Google Workspace Events API dan Google Cloud Pub/Sub untuk mengamati dan bereaksi terhadap acara rapat. Catatan aplikasi contoh saat konferensi dimulai dan berakhir, kapan peserta bergabung atau keluar, dan kapan artefak rapat yang dibuat yang tersedia.

Untuk mempelajari lebih lanjut cara mengelola acara, lihat Berlangganan Google Meet peristiwa di Google Workspace Events API dokumentasi tambahan.

Prasyarat

Jika Anda perlu mengaktifkan salah satu prasyarat ini untuk organisasi Anda, minta administrator Google Workspace Anda untuk mengaktifkannya:

• Akun Google Workspace dengan akses ke Google Meet.
• Akses untuk membuat project Google Cloud.
• Python 3 yang diinstal.
• gcloud CLI yang sudah diinstal.

Menyiapkan lingkungan Anda

Bagian ini menunjukkan cara membuat dan mengonfigurasi lingkungan lokal Anda dan Project Google Cloud untuk tutorial ini.

Membuat direktori kerja dan lingkungan virtual Python

Untuk membuat dan mengaktifkan virtual baru lingkungan, jalankan perintah di terminal Anda.

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

Membuat project Google Cloud

Mengaktifkan penagihan untuk project Google Cloud

Menyiapkan autentikasi dan otorisasi

Autentikasi dan otorisasi memungkinkan aplikasi mengakses Meet REST API Google Cloud Platform. Otorisasi pengguna diperlukan untuk memanggil Meet REST API. Bagian ini menjelaskan cara mengonfigurasi kredensial pengguna dan meminta otorisasi.

Mengonfigurasi layar izin OAuth dan memilih cakupan

Langkah-langkah berikut menyarankan informasi placeholder untuk dikonfigurasi layar izin OAuth untuk aplikasi Anda. Sebelum memublikasikan aplikasi secara eksternal, perbarui informasi ini.

1. Di konsol Google Cloud, buka Menu menu > API & Layanan > Layar izin OAuth.

   Buka layar izin OAuth

2. Di bagian Jenis pengguna, pilih Internal, lalu klik Buat.
3. Di App name, masukkan Meet REST API Tutorial.
4. Lengkapi formulir pendaftaran aplikasi, lalu klik Simpan dan Lanjutkan.
5. Klik Add or Remove Scopes. Panel akan muncul dengan daftar cakupan untuk setiap API yang telah Anda aktifkan di project Google Cloud.
6. Di bagian Tambahkan cakupan secara manual, tempel cakupan berikut:
   • https://www.googleapis.com/auth/meetings.space.created
7. Klik Tambahkan ke Tabel.
8. Klik Perbarui.
9. Setelah memilih cakupan yang diperlukan oleh aplikasi Anda, klik Simpan dan Lanjutkan.
10. Jika Anda memilih Eksternal untuk jenis pengguna, tambahkan pengguna uji coba:
    1. Di bagian Pengguna uji coba, klik Tambahkan pengguna.
    2. Masukkan alamat email Anda dan pengguna uji coba resmi lainnya, lalu klik Simpan dan Lanjutkan.
11. Tinjau ringkasan pendaftaran aplikasi Anda. Untuk melakukan perubahan, klik Edit. Jika aplikasi pendaftaran tampak tidak bermasalah, klik Kembali ke Dasbor.

Membuat client ID

Client ID bertindak sebagai kredensial untuk aplikasi Anda selama OAuth 2.0 {i>flow<i} (alur). Karena aplikasi berjalan secara lokal, buat client ID desktop.

1. Di konsol Google Cloud, buka Menu menu &gt; APIs & Layanan &gt; Kredensial.

   Buka Kredensial

2. Klik Create Credentials &gt; OAuth client ID.
3. Klik Jenis aplikasi &gt; Aplikasi desktop.
4. Di kolom Name, ketik nama untuk kredensial tersebut. Nama ini hanya ditampilkan di Konsol Google Cloud.
5. Klik Buat. Layar yang dibuat klien OAuth akan muncul, yang menunjukkan Client ID dan Rahasia klien baru Anda.
6. Klik Oke. Kredensial yang baru dibuat akan muncul di bagian Client ID OAuth 2.0.

Menginstal library autentikasi Google

Instal library autentikasi Google:

pip install google-auth google-auth-oauthlib

Menjalankan otorisasi

Meet REST API memerlukan kredensial pengguna dalam bentuk OAuth 2.0 token masing-masing. Di bagian ini, Anda akan menerapkan alur OAuth 2.0 untuk meminta token akses dan token refresh untuk pengguna.

1. Di direktori kerja, buat file main.py dan tambahkan kode berikut konten:

   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. Untuk menjalankan kode, {i>client ID<i} dan rahasia yang dibuat sebelumnya adalah tidak diperlukan. Menyalin file rahasia klien yang didownload ke project yang berfungsi dan mengganti namanya menjadi client_secret.json.

3. Jika Anda ingin menguji cara kerja otorisasi, jalankan perintah berikut. Aplikasi meminta otorisasi dan membuat file token.json di direktori kerja proyek setelah permintaan disetujui.

   python3 main.py
   

Menambahkan Meet REST API

Setelah kode otorisasi selesai, saatnya mengaktifkan dan memanggil Perkenalkan REST API.

Mengaktifkan API

Meskipun bagian ini berfokus pada Meet REST API, tutorial ini juga menggunakan Google Cloud Pub/Sub dan Google Workspace Events API.

Menginstal library klien Meet REST API

Ikuti langkah-langkah berikut untuk menginstal library klien Meet REST API:

1. Jalankan perintah:

   pip install google-apps-meet
   

2. Edit file main.py untuk mengimpor klien:

   from google.apps import meet_v2 as meet
   

Membuat ruang

Setelah Meet REST API tersedia, tentukan fungsi untuk membuat ruang rapat yang dapat ditempatkan untuk berlangganan.

Edit main.py dan tambahkan:

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

Berlangganan peristiwa

Untuk menerima acara tentang ruang rapat, Anda dapat membuat langganan menggunakan Google Workspace Events API. Anda juga harus membuat dan berlangganan topik Google Cloud Pub/Sub yang berfungsi sebagai endpoint notifikasi tempat aplikasi menerima peristiwa tersebut.

Mengonfigurasi Google Cloud Pub/Sub

Untuk membuat dan berlangganan topik Pub/Sub:

Catat nama topik dan pastikan nilai untuk {project} adalah ID project Cloud untuk aplikasi Anda. Anda akan menggunakan nama topik untuk membuat langganan Google Workspace nanti.

Membuat akun layanan

Menggunakan akun layanan

Setelah membuat akun layanan, beri diri Anda akses untuk meniru identitas akun layanan.

Menginstal library klien Pub/Sub

1. Gunakan pip untuk menginstal library klien untuk Pub/Sub:

   pip install google-cloud-pubsub
   

2. Lalu, edit main.py untuk mengimpor klien:

   from google.cloud import pubsub_v1
   

Membuat langganan Google Workspace

Tambahkan kode berikut ke main.py untuk menentukan metode berlangganan Acara Meet. Kode ini berlangganan semua acara untuk rapat spasi. Saat berlangganan, peristiwa diposting ke topik 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

Selanjutnya, tambahkan kode yang sesuai untuk mengambil dan memproses peristiwa.

Memproses dan menangani peristiwa

Lanjutkan mengedit main.py dan tambahkan kode contoh berikut. Kode ini mengimplementasikan sisi penerima dan menggunakan Google Cloud Pub/Sub API untuk mengambil peristiwa saat tersedia. Berbagai metode pengendali mencetak informasi tentang peristiwa yang sesuai.

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

Menyelesaikan kode

Tambahkan kode berikut ke main.py untuk memanggil metode membuat ruang, berlangganan acara, dan mendengarkan. Mengupdate TOPIC_NAME dan konstanta SUBSCRIPTION_NAME dengan topik Anda sendiri dan nama langganan yang sebelumnya Anda dibuat.

1. Tambahkan kode ke 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)
   listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   

   Ganti kode berikut:

   • PROJECT_ID: Project ID Cloud unik untuk aplikasi Anda, seperti my-sample-project-191923.

   • TOPIC_ID: Nama topik Pub/Sub yang Anda yang dibuat di project Cloud Anda.

   • SUBSCRIPTION_ID: Nama langganan Anda, seperti sebagai workspace-events-sub.

2. Jalankan program:

   python3 main.py
   

Jika Anda belum pernah menjalankan program tersebut, Anda akan diminta untuk pertama kalinya. Berikan akses ke aplikasi untuk memanggil Meet REST API. Setelah program berhasil berjalan, Anda akan melihat output seperti:

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

Bergabung dalam konferensi

Untuk membuat acara bagi aplikasi, bergabunglah ke konferensi menggunakan URL yang ditampilkan oleh aplikasi. Setelah bergabung, Anda dapat mencoba tindakan berikut untuk peristiwa pemicu:

• Keluar dan bergabung kembali ke rapat.
• Undang orang lain atau bergabung melalui telepon dengan ponsel Anda.
• Aktifkan rekaman dan transkrip.

Tiap aktivitas ini menghasilkan peristiwa yang diterima aplikasi dan log ke konsol Google Cloud.

Gunakan ctrl-c untuk menginterupsi program setelah selesai.

Opsional: Langkah tambahan yang dapat dicoba

Aplikasi mencatat detail dasar tentang peristiwa tersebut ke dalam log. Untuk terus mengeksplorasi Perkenalkan REST API, coba modifikasi aplikasi untuk melakukan tindakan.

• Gunakan People API untuk mengambil informasi tambahan tentang peserta yang login.
• Menggunakan Google Drive API untuk mendownload rekaman dan transkrip.
• Alih-alih mendownload transkrip dari Google Drive, ambil transkrip tersebut menggunakan transkrip terstruktur metode di Meet REST API.

Opsional: Pembersihan

Agar tidak menimbulkan biaya pada akun konsol Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, kami sarankan agar Anda membersihkan semua sumber daya dan proyek dibuat.

Untuk menghapus langganan:

Untuk menghapus topik:

Untuk menghapus project:

Topik terkait

• Pelajari lebih lanjut apa yang dapat dilakukan REST API Google Meet dan baca dokumentasi referensi.
• Baca cara Berlangganan acara menggunakan Acara Google Workspace Google Cloud Platform.
• Untuk mempelajari autentikasi lebih lanjut, lihat Mengonfigurasi layar izin OAuth lalu memilih cakupan.