Obserwowanie wydarzeń dotyczących spotkań za pomocą Pythona i interfejsu Google Meet REST API

W tym samouczku pokazujemy, jak używać interfejsu Google Meet REST API wraz z interfejsem Google Workspace Events API i Google Cloud Pub/Sub, aby obserwować zdarzenia w przestrzeni spotkań Meet i na nie reagować. Przykładowa aplikacja rejestruje, kiedy rozpoczynają się i kończą konferencje, kiedy uczestnicy dołączają do nich lub je opuszczają oraz kiedy są dostępne wygenerowane artefakty spotkania.

Zamiast subskrybować konkretny pokój spotkań, możesz subskrybować użytkownika Meet, aby otrzymywać informacje o wydarzeniach w dowolnym pokoju spotkań, którego jest właścicielem lub organizatorem. Szczegółowe informacje znajdziesz w artykule Subskrybowanie zdarzeń w Google Meet w dokumentacji interfejsu Google Workspace Events API.

Wymagania wstępne

Jeśli chcesz włączyć w organizacji któryś z tych warunków wstępnych, poproś o to administratora Google Workspace:

• Konto Google Workspace z dostępem do Google Meet.
• Uprawnienia do tworzenia projektu Google Cloud.
• Zainstalowany Python 3.
• Zainstalowany interfejs wiersza poleceń gcloud.

Przygotowywanie środowiska

W tej sekcji dowiesz się, jak utworzyć i skonfigurować środowisko lokalne oraz projekt Google Cloud na potrzeby tego samouczka.

Tworzenie katalogu roboczego i wirtualnego środowiska Pythona

Aby utworzyć i aktywować nowe środowisko wirtualne, uruchom w terminalu te polecenia:

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

Tworzenie projektu Google Cloud

Włączanie płatności za projekt Google Cloud

Konfigurowanie uwierzytelniania i autoryzacji

Uwierzytelnianie i autoryzacja umożliwiają aplikacji dostęp do zasobów interfejsu API REST usługi Meet. Aby wywołać interfejs API REST Meet, musisz mieć autoryzację użytkownika. W tej sekcji dowiesz się, jak skonfigurować dane logowania użytkownika i poprosić o autoryzację.

Konfigurowanie ekranu zgody OAuth i wybieranie zakresów

Poniższe kroki zawierają przykładowe informacje, które pomogą Ci skonfigurować ekran zgody OAuth w przypadku Twojej aplikacji. Przed opublikowaniem aplikacji na zewnątrz zaktualizuj te informacje.

1. W konsoli Google Cloud otwórz Menu menu > Google Auth platform > Branding.

   Otwórz Promowanie marki

2. Jeśli masz już skonfigurowany Google Auth platform, możesz skonfigurować te ustawienia ekranu zgody OAuth w sekcjach Branding, Odbiorcy i Dostęp do danych. Jeśli zobaczysz komunikat Google Auth platform Jeszcze nie skonfigurowano, kliknij Rozpocznij:
1. W sekcji Informacje o aplikacji w polu Nazwa aplikacji wpisz Meet REST API Tutorial.
2. W sekcji Adres e-mail pomocy dla użytkowników wybierz adres e-mail, na który użytkownicy mogą pisać, jeśli mają pytania dotyczące ich zgody.
3. Kliknij Dalej.
4. W sekcji Odbiorcy wybierz Wewnętrzny.
5. Kliknij Dalej.
6. W sekcji Dane kontaktowe wpisz adres e-mail, na który będziesz otrzymywać powiadomienia o wszelkich zmianach w projekcie.
7. Kliknij Dalej.
8. W sekcji Zakończ zapoznaj się z zasadami dotyczącymi danych użytkownika w usługach interfejsów API Google i jeśli się z nimi zgadzasz, kliknij Akceptuję zasady dotyczące danych użytkownika w usługach interfejsów API Google.
9. Kliknij Dalej.
10. Kliknij Utwórz.
11. Jeśli jako typ użytkownika wybierzesz Zewnętrzny, dodaj użytkowników testowych:
    1. Kliknij Odbiorcy.
    2. W sekcji Użytkownicy testowi kliknij Dodaj użytkowników.
    3. Wpisz swój adres e-mail i adresy e-mail innych autoryzowanych testerów, a następnie kliknij Zapisz.
3. Kliknij Dostęp do danych > Dodaj lub usuń zakresy. Pojawi się panel z listą zakresów każdego interfejsu API włączonego w projekcie Google Cloud.
4. W sekcji Ręczne dodawanie zakresów wklej te zakresy:
   • https://www.googleapis.com/auth/meetings.space.created
5. Kliknij Dodaj do tabeli.
6. Kliknij Aktualizuj.
7. Po wybraniu zakresów wymaganych przez aplikację kliknij Zapisz.

Więcej informacji o konfigurowaniu zgody OAuth znajdziesz w artykule Pierwsze kroki z Google Auth platform.

Tworzenie identyfikatora klienta

Identyfikator klienta pełni funkcję danych uwierzytelniających Twojej aplikacji podczas przepływów OAuth 2.0. Aplikacja działa lokalnie, więc utwórz identyfikator klienta na komputer.

1. W konsoli Google Cloud otwórz Menu menu > Google Auth platform > Klienci.

   Otwórz stronę Klienci

2. Kliknij Utwórz klienta.
3. Kliknij Typ aplikacji > Aplikacja na komputer.
4. W polu Nazwa wpisz nazwę danych logowania. Ta nazwa jest widoczna tylko w konsoli Google Cloud.
5. Kliknij Utwórz.

   Nowo utworzone dane logowania pojawią się w sekcji „Identyfikatory klientów OAuth 2.0”.

Instalowanie bibliotek uwierzytelniania Google

Zainstaluj biblioteki uwierzytelniania Google:

pip install google-auth google-auth-oauthlib

Wykonanie autoryzacji

Interfejs Meet REST API wymaga danych logowania użytkownika w postaci tokena dostępu OAuth 2.0. W tej sekcji zaimplementujesz proces OAuth 2.0, aby poprosić o token dostępu i token odświeżania dla użytkownika.

1. W katalogu roboczym utwórz plik main.py i dodaj do niego tę treść:

   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. Aby uruchomić kod, potrzebne są utworzone wcześniej identyfikator klienta i tajny klucz. Skopiuj pobrany plik klucza tajnego klienta do katalogu roboczego projektu i zmień jego nazwę na client_secret.json.

3. Jeśli chcesz sprawdzić, jak działa autoryzacja, uruchom to polecenie. Po zatwierdzeniu prośby aplikacja poprosi o autoryzację i utworzy plik token.json w katalogu roboczym projektu.

   python3 main.py

Dodawanie interfejsu Meet REST API

Kod autoryzacji jest już gotowy, więc możesz włączyć i wywołać interfejs Meet REST API.

Włączanie interfejsów API

Ta sekcja skupia się na interfejsie Meet REST API, ale w tym samouczku używane są też interfejsy Google Cloud Pub/Sub i Google Workspace Events API.

Instalowanie biblioteki klienta interfejsu Meet REST API

Aby zainstalować bibliotekę klienta interfejsu Meet REST API:

1. Uruchom polecenie:

   pip install google-apps-meet

2. Aby zaimportować klienta, edytuj plik main.py:

   from google.apps import meet_v2 as meet
   

Utwórz pokój

Teraz, gdy interfejs Meet REST API jest już dostępny, zdefiniuj funkcję tworzenia przestrzeni spotkań, do której można się subskrybować.

Edytuj main.py i dodaj:

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

Subskrybowanie zdarzeń

Aby otrzymywać zdarzenia dotyczące miejsca spotkań, utwórz subskrypcję za pomocą interfejsu Google Workspace Events API. Musisz też utworzyć temat Google Cloud Pub/Sub i zasubskrybować go. Będzie on służyć jako punkt końcowy powiadomień, w którym Twoja aplikacja będzie odbierać zdarzenia.

Konfigurowanie Google Cloud Pub/Sub

Aby utworzyć temat Pub/Sub i zasubskrybować go:

Zanotuj nazwę tematu i sprawdź, czy wartość {project} to identyfikator projektu w Google Cloud dla Twojej aplikacji. Nazwy tematu użyjesz później do utworzenia subskrypcji Google Workspace.

Tworzenie konta usługi

Używanie konta usługi

Po utworzeniu konta usługi przyznaj sobie dostęp do podszywania się pod to konto.

Instalowanie biblioteki klienta Pub/Sub

1. Użyj pip, aby zainstalować bibliotekę klienta Pub/Sub:

   pip install google-cloud-pubsub

2. Następnie edytuj main.py, aby zaimportować klienta:

   from google.cloud import pubsub_v1
   

Tworzenie subskrypcji Google Workspace

Dodaj do main.py ten kod, aby zdefiniować metodę subskrybowania zdarzeń Meet. Ten kod subskrybuje wszystkie zdarzenia dotyczące przestrzeni do spotkań. Po zasubskrybowaniu zdarzenia są publikowane w temacie 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

Następnie dodaj odpowiedni kod, aby pobrać i przetworzyć zdarzenia.

Nasłuchiwanie i obsługa zdarzeń

Kontynuuj edycję pliku main.py i dodaj poniższy przykładowy kod. Ten kod implementuje stronę odbiorczą i używa interfejsu Google Cloud Pub/Sub API do pobierania zdarzeń, gdy tylko staną się dostępne. Poszczególne metody obsługi wyświetlają informacje o odpowiednich zdarzeniach.

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

Finalizowanie kodu

Dodaj do pliku main.py ten kod, aby wywołać metody tworzenia przestrzeni, subskrybowania zdarzeń i nasłuchiwania. Zastąp stałe TOPIC_NAME i SUBSCRIPTION_NAME własnymi nazwami tematu i subskrypcji, które zostały wcześniej utworzone.

1. Dodaj kod do pliku 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}")
   

   Zastąp następujące elementy:

   • PROJECT_ID: unikalny identyfikator projektu Cloud Twojej aplikacji, np. my-sample-project-191923.

   • TOPIC_ID: nazwa tematu Pub/Sub utworzonego w projekcie Cloud.

   • SUBSCRIPTION_ID: Nazwa subskrypcji, np. workspace-events-sub.

2. Uruchom program:

   python3 main.py

Jeśli program nie był wcześniej uruchamiany, przy pierwszym uruchomieniu pojawi się prośba o autoryzację. Przyznaj aplikacji uprawnienia do wywoływania interfejsu Meet REST API. Po uruchomieniu programu powinny pojawić się dane wyjściowe podobne do tych:

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

Dołączanie do konferencji

Aby wygenerować zdarzenia dla aplikacji, dołącz do konferencji, korzystając z adresu URL wyświetlanego przez aplikację. Po dołączeniu możesz wypróbować te działania, aby wywołać zdarzenia:

• Opuść spotkanie i dołącz do niego ponownie.
• Zapraszanie innych osób lub nawiązywanie połączenia telefonicznego.
• Włącz nagrywanie i transkrypcje.

Każda z tych czynności generuje zdarzenie, które aplikacja odbiera i rejestruje w konsoli Google Cloud.

Gdy skończysz, użyj ctrl-c, aby przerwać działanie programu.

Opcjonalnie: dodatkowe kroki

Aplikacja rejestruje podstawowe informacje o zdarzeniach. Aby kontynuować zapoznawanie się z interfejsem Meet REST API, spróbuj zmodyfikować aplikację, aby wykonywała te dodatkowe działania.

• Użyj interfejsu People API, aby pobrać dodatkowe informacje o zalogowanych uczestnikach.

  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)
  

  W przykładowych danych logowania powyżej dodaj „https://www.googleapis.com/auth/userinfo.profile” w metodzie autoryzacji.

• Użyj interfejsu Google Drive API, aby pobrać nagrania i transkrypcje.

• Zamiast pobierać transkrypcje z Dysku Google, pobieraj je za pomocą metod transkrypcji strukturalnej w interfejsie Meet REST API.

• uzyskać dostęp do pokoju zamiast go tworzyć;

  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)
  

  W przykładowych danych logowania powyżej dodaj „https://www.googleapis.com/auth/meetings.space.readonly” w metodzie authorize.

Opcjonalnie: czyszczenie

Aby uniknąć obciążenia konta w konsoli Google Cloud opłatami za zasoby użyte w tym samouczku, zalecamy usunięcie wszystkich utworzonych zasobów i projektów.

Aby usunąć subskrypcję:

Aby usunąć temat:

Aby usunąć projekt:

Powiązane artykuły

• Dowiedz się więcej o rodzajach wydarzeń w Meet, na które możesz się subskrybować.
• Dowiedz się więcej o możliwościach interfejsu Google Meet REST API i zapoznaj się z dokumentacją.
• Tworzenie subskrypcji Google Workspace w przypadku przestrzeni spotkań lub użytkowników Meet za pomocą interfejsu Google Workspace Events API.
• Więcej informacji o uwierzytelnianiu znajdziesz w artykule Konfigurowanie ekranu zgody OAuth i wybieranie zakresów.