Osserva gli eventi delle riunioni con Python e l'API REST di Google Meet

Questo tutorial mostra come utilizzare l'API REST di Google Meet insieme all'API Google Workspace Events e a Google Cloud Pub/Sub per osservare e reagire agli eventi in uno spazio di riunione Meet. L'applicazione di esempio registra l'inizio e la fine delle conferenze, quando i partecipanti si uniscono o abbandonano la riunione e quando sono disponibili gli artefatti della riunione generati.

Anziché iscriverti a uno spazio riunioni specifico, puoi iscriverti a un utente Meet per ricevere eventi per qualsiasi spazio riunioni di proprietà o organizzato dall'utente. Per maggiori dettagli, consulta la sezione Iscriversi agli eventi di Google Meet nella documentazione dell'API Google Workspace Events.

Prerequisiti

Se devi attivare uno di questi prerequisiti per la tua organizzazione, chiedi all'amministratore di Google Workspace di attivarli:

• Un account Google Workspace con accesso a Google Meet.
• Accesso per creare un progetto Google Cloud.
• Python 3 installato.
• gcloud CLI installata.

prepara l'ambiente

Questa sezione mostra come creare e configurare l'ambiente locale e il progetto Google Cloud per questo tutorial.

Crea una directory di lavoro e un ambiente virtuale Python

Per creare e attivare un nuovo ambiente virtuale, esegui i seguenti comandi nel terminale.

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

Crea un progetto Google Cloud

Abilitare la fatturazione per il progetto Google Cloud

Configurare l'autenticazione e l'autorizzazione

L'autenticazione e l'autorizzazione consentono all'app di accedere alle risorse dell'API REST di Meet. Per chiamare l'API REST di Meet è necessaria l'autorizzazione dell'utente. Questa sezione mostra come configurare le credenziali utente e richiedere l'autorizzazione.

Configurare la schermata per il consenso OAuth e scegliere gli ambiti

I seguenti passaggi suggeriscono informazioni segnaposto per configurare la schermata per il consenso OAuth per la tua app. Prima di pubblicare l'app esternamente, aggiorna queste informazioni.

1. Nella console Google Cloud, vai a Menu menu > Google Auth platform > Branding.

   Vai a Branding

2. Se hai già configurato Google Auth platform, puoi configurare le seguenti impostazioni della schermata per il consenso OAuth in Branding, Pubblico e Accesso ai dati. Se viene visualizzato il messaggio Google Auth platform non ancora configurata, fai clic su Inizia:
1. Nella sezione Informazioni sull'app, nel campo Nome app, inserisci Meet REST API Tutorial.
2. In Email dell'assistenza utente, scegli un indirizzo email dell'assistenza a cui gli utenti possono contattarti in caso di domande sul loro consenso.
3. Fai clic su Avanti.
4. Nella sezione Pubblico, seleziona Interno.
5. Fai clic su Avanti.
6. In Informazioni di contatto, inserisci un indirizzo email a cui ricevere notifiche in caso di modifiche al tuo progetto.
7. Fai clic su Avanti.
8. In Fine, esamina le Norme relative ai dati utente dei servizi API di Google e, se le accetti, seleziona Accetto le Norme relative ai dati utente dei servizi API di Google.
9. Fai clic su Continua.
10. Fai clic su Crea.
11. Se hai selezionato Esterno per il tipo di utente, aggiungi utenti di test:
    1. Fai clic su Segmento di pubblico.
    2. Nella sezione Utenti di test, fai clic su Aggiungi utenti.
    3. Inserisci il tuo indirizzo email e gli altri utenti di test autorizzati, quindi fai clic su Salva.
3. Fai clic su Accesso ai dati > Aggiungi o rimuovi ambiti. Viene visualizzato un riquadro con un elenco di ambiti per ogni API che hai abilitato nel tuo progetto Google Cloud.
4. In Aggiungi ambiti manualmente, incolla i seguenti ambiti:
   • https://www.googleapis.com/auth/meetings.space.created
5. Fai clic su Aggiungi alla tabella.
6. Fai clic su Aggiorna.
7. Dopo aver selezionato gli ambiti richiesti dalla tua app, fai clic su Salva.

Per maggiori informazioni sulla configurazione del consenso OAuth, consulta la pagina Guida introduttiva all' Google Auth platform.

Creare un ID client

L'ID client funge da credenziali per la tua applicazione durante i flussi OAuth 2.0. Poiché l'app viene eseguita localmente, crea un ID client desktop.

1. Nella console Google Cloud, vai a Menu menu > Google Auth platform > Client.

   Vai a Clienti

2. Fai clic su Crea cliente.
3. Fai clic su Tipo di applicazione > App per computer.
4. Nel campo Nome, digita un nome per la credenziale. Questo nome viene visualizzato solo nella console Google Cloud.
5. Fai clic su Crea.

   La credenziale appena creata viene visualizzata in "ID client OAuth 2.0".

Installa le librerie di autenticazione Google

Installa le librerie di autenticazione Google:

pip install google-auth google-auth-oauthlib

Esegui autorizzazione

L'API REST di Meet richiede le credenziali utente sotto forma di token di accesso OAuth 2.0. In questa sezione, implementa il flusso OAuth 2.0 per richiedere un token di accesso e un token di aggiornamento per l'utente.

1. Nella directory di lavoro, crea il file main.py e aggiungi il seguente contenuto:

   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. Per eseguire il codice, sono necessari sia l'ID client sia il secret creati in precedenza. Copia il file del secret client scaricato nella directory di lavoro del progetto e rinominalo come client_secret.json.

3. Se vuoi testare il funzionamento dell'autorizzazione, esegui il comando seguente. L'app richiede l'autorizzazione e crea un file token.json nella directory di lavoro del progetto dopo l'approvazione della richiesta.

   python3 main.py

Aggiungere l'API REST di Meet

Ora che il codice di autorizzazione è completo, è il momento di abilitare e chiamare l'API REST di Meet.

Abilita le API

Sebbene questa sezione sia incentrata sull'API REST di Meet, questo tutorial utilizza anche Google Cloud Pub/Sub e l'API Google Workspace Events.

Installare la libreria client dell'API REST di Meet

Segui questi passaggi per installare la libreria client dell'API REST di Meet:

1. Esegui il comando:

   pip install google-apps-meet

2. Modifica il file main.py per importare il cliente:

   from google.apps import meet_v2 as meet
   

Crea uno spazio

Ora che l'API REST di Meet è disponibile, definisci una funzione per creare uno spazio di riunione a cui è possibile iscriversi.

Modifica main.py e aggiungi:

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

Iscriviti agli eventi

Per ricevere eventi relativi a uno spazio riunioni, crea un abbonamento utilizzando l'API Google Workspace Events. Devi anche creare un argomento Google Cloud Pub/Sub e abbonarti a questo. L'argomento funge da endpoint di notifica in cui la tua app riceve gli eventi.

Configurare Google Cloud Pub/Sub

Per creare un argomento Pub/Sub e sottoscriverlo:

Prendi nota del nome dell'argomento e assicurati che il valore di {project} sia l'ID progetto Cloud della tua app. Utilizzerai il nome dell'argomento per creare l'abbonamento a Google Workspace in un secondo momento.

Crea un account di servizio

Utilizza il service account

Dopo aver creato il service account, concediti l'accesso per rappresentarlo.

Installare la libreria client Pub/Sub

1. Utilizza pip per installare la libreria client per Pub/Sub:

   pip install google-cloud-pubsub

2. Quindi modifica main.py per importare il cliente:

   from google.cloud import pubsub_v1
   

Crea l'abbonamento a Google Workspace

Aggiungi il seguente codice a main.py per definire un metodo di iscrizione agli eventi di Meet. Questo codice esegue la sottoscrizione a tutti gli eventi per uno spazio di riunione. Una volta eseguita l'iscrizione, gli eventi vengono pubblicati nell'argomento 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

Poi, aggiungi il codice corrispondente per estrarre ed elaborare gli eventi.

Ascoltare e gestire gli eventi

Continua a modificare main.py e aggiungi il seguente codice campione. Questo codice implementa il lato ricezione e utilizza l'API Google Cloud Pub/Sub per recuperare gli eventi man mano che vengono resi disponibili. I vari metodi di gestione stampano informazioni sugli eventi corrispondenti.

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

Finalizza il codice

Aggiungi il seguente codice a main.py per chiamare i metodi per creare lo spazio, iscriversi agli eventi e ascoltare. Aggiorna le costanti TOPIC_NAME e SUBSCRIPTION_NAME con i nomi di argomento e sottoscrizione che hai creato in precedenza.

1. Aggiungi il codice a 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}")
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID progetto Cloud univoco per la tua app, ad esempio my-sample-project-191923.

   • TOPIC_ID: il nome dell'argomento Pub/Sub che hai creato nel tuo progetto Cloud.

   • SUBSCRIPTION_ID: il nome dell'abbonamento, ad esempio workspace-events-sub.

2. Esegui il programma:

   python3 main.py

Se non hai mai eseguito il programma, la prima volta ti viene richiesta l'autorizzazione. Concedi all'applicazione l'accesso per chiamare l'API REST di Meet. Dopo l'esecuzione corretta del programma, dovresti visualizzare un output simile al seguente:

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

Partecipare alla conferenza

Per generare eventi per l'applicazione, partecipa alla conferenza utilizzando l'URL visualizzato dall'applicazione. Dopo aver accettato l'invito, puoi provare queste azioni per attivare gli eventi:

• Esci e rientra nella riunione.
• Invita altre persone o partecipa alla chiamata con il tuo telefono.
• Attiva le registrazioni e le trascrizioni.

Ognuna di queste attività genera un evento che l'applicazione riceve e registra nella console Google Cloud.

Utilizza ctrl-c per interrompere il programma al termine.

(Facoltativo) Ulteriori procedure da provare

L'app registra i dettagli di base sugli eventi. Per continuare a esplorare l'API REST di Meet, prova a modificare l'applicazione per eseguire queste azioni aggiuntive.

• Utilizza l'API People per recuperare ulteriori informazioni sui partecipanti che hanno eseguito l'accesso.

  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)
  

  Assicurati di aggiungere "https://www.googleapis.com/auth/userinfo.profile" nel metodo authorize negli esempi di credenziali riportati sopra.

• Utilizza l'API Google Drive per scaricare registrazioni e trascrizioni.

• Anziché scaricare le trascrizioni da Google Drive, recuperale utilizzando i metodi di trascrizione strutturata nell'API REST di Meet.

• get space instead of creating the space

  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)
  

  Assicurati di aggiungere "https://www.googleapis.com/auth/meetings.space.readonly" nel metodo authorize negli esempi di credenziali riportati sopra.

(Facoltativo) Pulizia

Per evitare che al tuo account della console Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, ti consigliamo di eliminare tutte le risorse e i progetti creati.

Per eliminare l'abbonamento:

Per eliminare l'argomento:

Per eliminare il progetto:

Argomenti correlati

• Scopri di più sui tipi di eventi di Meet a cui puoi iscriverti.
• Scopri di più su cosa può fare l'API REST di Google Meet e consulta la documentazione di riferimento.
• Crea un abbonamento Google Workspace per gli spazi di riunione o gli utenti di Meet utilizzando l'API Google Workspace Events.
• Per saperne di più sull'autenticazione, consulta Configurare la schermata per il consenso OAuth e scegliere gli ambiti.