Acompanhe eventos de reuniões com Python e a API REST do Google Meet

Este tutorial mostra como usar a API REST do Google Meet com a API Events do Google Workspace e o Google Cloud Pub/Sub para observar e reagir a eventos em um espaço de reunião do Meet. O aplicativo de exemplo registra quando as conferências começam e terminam, quando os participantes entram ou saem e quando os artefatos de reunião gerados estão disponíveis.

Em vez de se inscrever em um espaço de reunião específico, você pode se inscrever em um usuário do Meet para receber eventos de qualquer espaço de reunião que o usuário tenha ou organize. Para mais detalhes, consulte Inscrever-se em eventos do Google Meet na documentação da API Google Workspace Events.

Pré-requisitos

Se você precisar ativar algum desses pré-requisitos na sua organização, peça ao administrador do Google Workspace para fazer isso:

• Uma conta do Google Workspace com acesso ao Google Meet.
• Acesso para criar um projeto do Google Cloud.
• Python 3 instalado.
• A CLI gcloud instalada.

Preparar o ambiente

Esta seção mostra como criar e configurar seu ambiente local e o projeto do Google Cloud para este tutorial.

Criar um diretório de trabalho e um ambiente virtual do Python

Para criar e ativar um novo ambiente virtual, execute os seguintes comandos no terminal.

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

Criar um projeto do Google Cloud

Ativar o faturamento para o projeto do Google Cloud

Configurar a autenticação e a autorização

A autenticação e a autorização permitem que o app acesse os recursos da API REST do Meet. A autorização do usuário é necessária para chamar a API REST do Meet. Esta seção mostra como configurar as credenciais do usuário e solicitar autorização.

Configurar a tela de consentimento OAuth e escolher escopos

As etapas a seguir sugerem informações de marcador de posição para configurar a tela de consentimento do OAuth para o app. Antes de publicar o app externamente, atualize essas informações.

1. No console do Google Cloud, acesse Menu menu > APIs e serviços > Tela de consentimento do OAuth.

   Acessar a tela de permissão OAuth

2. Em Tipo de usuário, selecione Interno e clique em Criar.
3. Em Nome do app, insira Meet REST API Tutorial.
4. Preencha o formulário de registro do app e clique em Salvar e continuar.
5. Clique em Adicionar ou remover escopos. Um painel aparece com uma lista de escopos para cada API que você ativou no projeto do Google Cloud.
6. Em Adicionar escopos manualmente, cole os seguintes escopos:
   • https://www.googleapis.com/auth/meetings.space.created
7. Clique em Adicionar à tabela.
8. Clique em Atualizar.
9. Depois de selecionar os escopos necessários pelo app, clique em Salvar e continuar.
10. Se você selecionou Externo como tipo de usuário, adicione usuários de teste:
    1. Em Test Users, clique em Add users.
    2. Insira seu endereço de e-mail e os outros usuários de teste autorizados. Depois, clique em Salvar e continuar.
11. Analise o resumo do registro do app. Para fazer alterações, clique em Editar. Se o registro do app estiver correto, clique em Voltar ao painel.

Criar um Client-ID

O ID do cliente funciona como credenciais para seu aplicativo durante os fluxos do OAuth 2.0. Como o app é executado localmente, crie um ID de cliente para computador.

1. No console do Google Cloud, acesse Menu menu > APIs e serviços > Credenciais.

   Ir para Credenciais

2. Clique em Criar credenciais > ID do cliente OAuth.
3. Clique em Tipo de aplicativo > App para computador.
4. No campo Nome, digite um nome para a credencial. Esse nome é mostrado apenas no console do Google Cloud.
5. Clique em Criar. A tela do cliente OAuth criado aparece, mostrando o novo ID e a chave secreta do cliente.
6. Clique em OK. A credencial recém-criada aparece em IDs de cliente OAuth 2.0.

Instalar as bibliotecas de autenticação do Google

Instale as bibliotecas de autenticação do Google:

pip install google-auth google-auth-oauthlib

Executar autorização

A API REST do Meet exige credenciais do usuário na forma de um token de acesso OAuth 2.0. Nesta seção, você vai implementar o fluxo OAuth 2.0 para solicitar um token de acesso e um token de atualização para o usuário.

1. No diretório de trabalho, crie o arquivo main.py e adicione o seguinte conteúdo:

   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. Para executar o código, são necessários o ID do cliente e a chave secreta criada anteriormente. Copie o arquivo de segredo do cliente transferido por download para o diretório de trabalho do projeto e renomeie-o como client_secret.json.

3. Se você quiser testar como a autorização funciona, execute o comando a seguir. O app solicita autorização e cria um arquivo token.json no diretório de trabalho do projeto depois que a solicitação é aprovada.

   python3 main.py

Adicionar a API REST do Meet

Agora que o código de autorização foi concluído, é hora de ativar e chamar a API REST do Meet.

Ative as APIs

Embora esta seção se concentre na API REST do Meet, este tutorial também usa a API Google Workspace Events e a Pub/Sub do Google Cloud.

Instalar a biblioteca de cliente da API REST do Meet

Siga estas etapas para instalar a biblioteca de cliente da API REST do Meet:

1. Execute o comando:

   pip install google-apps-meet

2. Edite o arquivo main.py para importar o cliente:

   from google.apps import meet_v2 as meet
   

Criar um espaço

Agora que a API REST do Meet está disponível, defina uma função para criar um espaço de reunião que possa ser assinado.

Edite main.py e adicione:

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

Inscrever-se em eventos

Para receber eventos sobre um espaço de reunião, crie uma assinatura usando a API Google Workspace Events. Você também precisa criar e assinar um tópico do Pub/Sub do Google Cloud que serve como o endpoint de notificação em que o app recebe os eventos.

Configurar o Google Cloud Pub/Sub

Para criar e se inscrever em um tópico do Pub/Sub:

Anote o nome do tópico e verifique se o valor de {project} é o ID do projeto do Cloud para o app. Você vai usar o nome do tópico para criar a assinatura do Google Workspace mais tarde.

Criar uma conta de serviço

Usar a conta de serviço

Depois de criar a conta de serviço, conceda a si mesmo acesso para falsificar a conta de serviço.

Instalar a biblioteca de cliente do Pub/Sub

1. Use pip para instalar a biblioteca de cliente do Pub/Sub:

   pip install google-cloud-pubsub

2. Em seguida, edite main.py para importar o cliente:

   from google.cloud import pubsub_v1
   

Criar a assinatura do Google Workspace

Adicione o código abaixo a main.py para definir um método de inscrição em eventos do Meet. Esse código se inscreve em todos os eventos de um espaço de reunião. Quando você se inscreve, os eventos são publicados no tópico do 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

Em seguida, adicione o código correspondente para extrair e processar os eventos.

Detectar e processar eventos

Continue editando main.py e adicione o código de exemplo abaixo. Esse código implementa o lado receptor e usa a API Google Cloud Pub/Sub para extrair eventos conforme eles são disponibilizados. Os vários métodos de gerenciador imprimem informações sobre os eventos correspondentes.

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

Finalizar o código

Adicione o código abaixo a main.py para chamar os métodos de criação do espaço, assinatura de eventos e escuta. Atualize as constantes TOPIC_NAME e SUBSCRIPTION_NAME com seus próprios nomes de tópico e assinatura que você criou anteriormente.

1. Adicione o código 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)
   listen_for_events(subscription_name=SUBSCRIPTION_NAME)
   

   Substitua:

   • PROJECT_ID: o ID exclusivo do projeto do Cloud para seu app, como my-sample-project-191923.

   • TOPIC_ID: o nome do tópico do Pub/Sub que você criou no projeto do Cloud.

   • SUBSCRIPTION_ID: o nome da sua assinatura, como workspace-events-sub.

2. Execute o programa:

   python3 main.py

Se você não tiver executado o programa anteriormente, ele solicitará autorização pela primeira vez. Conceder acesso ao aplicativo para chamar a API REST do Meet. Depois que o programa for executado, você verá uma saída semelhante a esta:

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

Participar da conferência

Para gerar eventos para o aplicativo, participe da conferência usando o URL exibido pelo aplicativo. Depois de participar, você pode tentar estas ações para acionar eventos:

• Saia e entre novamente na reunião.
• Convide outras pessoas ou ligue pelo telefone.
• Ative as gravações e transcrições.

Cada uma dessas atividades gera um evento que o aplicativo recebe e registra no console do Google Cloud.

Use ctrl-c para interromper o programa quando terminar.

Opcional: outras etapas que você pode testar

O app registra detalhes básicos sobre os eventos. Para continuar a explorar a API REST do Meet, tente modificar o aplicativo para realizar essas outras ações.

• Use a API People para recuperar mais informações sobre os participantes conectados.
• Use a API Google Drive para fazer o download de gravações e transcrições.
• Em vez de fazer o download de transcrições do Google Drive, extraia-as usando os métodos de transcrição estruturada na API REST do Meet.

Opcional: limpar

Para evitar cobranças na sua conta do console do Google Cloud pelos recursos usados neste tutorial, recomendamos que você limpe todos os recursos e projetos criados.

Para excluir a assinatura:

Para excluir o tópico:

Para excluir o projeto:

Temas relacionados

• Saiba mais sobre os tipos de eventos do Meet que você pode assinar.
• Saiba mais sobre o que a API REST do Google Meet pode fazer e consulte a documentação de referência.
• Crie uma assinatura do Google Workspace para espaços de reunião do Meet ou usuários usando a API Google Workspace Events.
• Para saber mais sobre a autenticação, consulte Configurar a tela de consentimento OAuth e escolher escopos.