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

Neste tutorial, mostramos como usar a API REST do Google Meet com a a API Google Workspace Events e o Google Cloud Pub/Sub para observar e reagir a e eventos de reunião. O aplicativo de exemplo registra quando as conferências começam e terminam, quando os participantes entram ou saem e quando qualquer artefato de reunião gerado é disponíveis.

Para saber mais sobre como trabalhar com eventos, consulte Assinar o Google Meet eventos na API Google Workspace Events na documentação do Google Cloud.

Pré-requisitos

Se você precisa ativar algum desses pré-requisitos na sua organização, peça seu administrador do Google Workspace para ativá-las:

• Uma conta do Google Workspace com acesso ao Google Meet.
• Acesso para criar um projeto do Google Cloud.
• O Python 3 (em inglês) instalado.
• A CLI gcloud instalada.

Preparar o ambiente

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

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

Para criar e ativar uma nova nova rede ambiente, execute o seguinte 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 do projeto do Google Cloud

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

A autenticação e a autorização permitem que o app acesse a API REST do Meet do Google Cloud. A autorização do usuário é necessária para chamar a API REST do Meet. Nesta seção, você aprende a configurar as credenciais do usuário e solicitar autorização.

Configurar a tela de permissão OAuth e escolher escopos

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

1. No console do Google Cloud, acesse o menu menu > APIs e Serviços > Tela de permissão 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, digite Meet REST API Tutorial.
4. Preencha o formulário de registro do app e clique em Save and continue.
5. Clique em Adicionar ou remover escopos. Será exibido um painel com uma lista de escopos. para cada API ativada 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. Após selecionar os escopos necessários ao lado do seu app, clique em Salvar e continuar.
10. Se você selecionou Externo como tipo de usuário, adicione usuários de teste:
    1. Em Usuários de teste, clique em Adicionar usuários.
    2. Insira seu endereço de e-mail e qualquer outro usuário de teste autorizado e clique em Salvar e continuar.
11. Analise o resumo do registro do app. Para fazer mudanças, clique em Editar. Se o app estiver tudo certo, clique em Voltar para o painel.

Criar um Client-ID

O ID do cliente funciona como credenciais para o aplicativo durante a OAuth 2.0 flui. Como o app é executado localmente, crie um ID do cliente para computadores.

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 só é mostrado no console do Google Cloud.
5. Clique em Criar. A tela criada pelo cliente OAuth será exibida, mostrando o novo ID e a chave secreta do cliente.
6. Clique em OK. A credencial recém-criada aparece em IDs do 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 de usuário na forma de um OAuth 2.0 token de acesso. Nesta seção, você vai implementar o fluxo do OAuth 2.0 para solicitar uma 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, tanto o ID do cliente quanto a chave secreta criados anteriormente são obrigatórios. Copie o arquivo da chave secreta do cliente baixado para o projeto que está e renomeie-o como client_secret.json.

3. Para testar como a autorização funciona, execute o comando a seguir. O app solicita autorização e cria um arquivo token.json no do projeto após a aprovação da solicitação.

   python3 main.py
   

Adicionar a API REST do Meet

Agora que o código de autorização está concluído, é hora de ativar e chamar o método Conheça a API REST.

Ative as APIs

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

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 para reuniões que pode ser inscrito.

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 para reuniões, crie uma assinatura usando o na API Google Workspace Events. Você também deve criar e se inscrever em um tópico do Google Cloud Pub/Sub, que serve como ponto de extremidade de notificação em que sua 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 Google Cloud para seu app. Você vai usar o nome do tópico para criar o 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 personificar o conta de serviço.

Instalar a biblioteca de cliente do Pub/Sub

1. Use pip para instalar a biblioteca de cliente para 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 seguinte código a main.py para definir um método de assinatura Eventos do Meet. Este código se inscreve em todos os eventos de uma reunião espaço. Quando inscritos, os eventos são postados 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 para editar main.py e adicione o exemplo de código a seguir. Este código implementa o receptor e usa a API do Google Cloud Pub/Sub para extrair conforme são disponibilizados. Os vários métodos de gerenciamento 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 ao main.py para chamar os métodos e criar o espaço. inscrever-se em eventos e ouvir. Atualize o TOPIC_NAME e constantes SUBSCRIPTION_NAME com seu próprio topic e nomes de assinaturas que você já criados.

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ê criados no projeto do Cloud.

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

2. Execute o programa:

   python3 main.py
   

Se você ainda não executou o programa, ele vai solicitar a autorização, pela primeira vez. Conceda acesso ao aplicativo para chamar a API REST do Meet. Após a execução do programa, você verá uma resposta semelhante a esta:

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

Participe da conferência

Para gerar eventos para o aplicativo, participe da conferência usando o URL exibidos pelo aplicativo. Depois disso, tente estas ações para eventos acionadores:

• Saia e entre novamente na reunião.
• Convide outras pessoas ou ligue para a reunião usando seu smartphone.
• Ativar gravações e transcrições.

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

Use ctrl-c para interromper o programa quando terminar.

Opcional: outras etapas a serem testadas

O app registra detalhes básicos sobre os eventos. Para continuar explorando o Conheça a API REST, tente modificar o aplicativo para executar essas ações.

• Use a API People para recuperar informações adicionais sobre participantes que fizeram login.
• Usar a API Google Drive para fazer o download das gravações. e transcrições.
• Em vez de fazer o download de transcrições do Google Drive, você pode recuperá-las usando o a transcrição estruturada métodos na API REST do Meet.

Opcional: limpar

Para evitar cobranças dos recursos na conta do console do Google Cloud 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 o que a API REST do Google Meet pode fazer e leia a documentação de referência.
• Leia sobre como se inscrever em eventos usando os eventos do Google Workspace. API.
• Para saber mais sobre a autenticação, consulte Configurar a tela de permissão OAuth e escolher os escopos.