Entendendo Eventos de Teclado

pwd

Resultado esperado: o caminho termina em Laboratorio-Keyloggers.

Resultado observado: registre o caminho que apareceu. Se estiver em outra pasta, abra a pasta correta no VS Code antes de continuar.

Status: ☐ aprovado ☐ reprovado ☐ não executado.

cd "$HOME/Laboratorio-Keyloggers"
source .venv/bin/activate
python --version
python -c "import sys; print(sys.executable)"
echo "$XDG_SESSION_TYPE"
echo "$DISPLAY"

Confirme a versão registrada na Aula 1 e que o caminho do interpretador termina em .venv/bin/python. As últimas duas linhas mostram o tipo de sessão gráfica e o servidor de exibição. Registre as saídas; não avance se o ambiente virtual não estiver ativo. Se DISPLAY aparecer vazio, abra o VS Code pelo menu gráfico do Linux Mint e crie um terminal integrado novo: o listener precisa herdar a sessão gráfica da VM. Se continuar vazio, pare e peça ajuda ao responsável pelo laboratório.

Registro: anote a versão, o caminho e o status do teste.

Precisamos da biblioteca pynput porque a demonstração usa pynput.keyboard.Listener, um observador que recebe eventos de teclado enquanto está ativo na VM. Antes de instalar, confira se o pacote já está disponível no ambiente virtual ativo:

python -m pip show pynput

Esperado: se instalado, o comando mostra nome, versão e localização. Se não for encontrado, instale somente no ambiente virtual do laboratório:

python -m pip install pynput

Depois da instalação, execute novamente python -m pip show pynput. Não avance até confirmar que o pacote está instalado no ambiente virtual ativo. Nunca execute a instalação com sudo.

Resultado observado/status: registre o que apareceu; marque aprovado, reprovado ou não executado.

No VS Code, com .venv ainda ativo, crie um arquivo chamado eventos_teclado.py na pasta do laboratório. Salve o arquivo antes de cada teste. A cada etapa, substitua ou acrescente exatamente o trecho indicado para que o arquivo permaneça executável.

from pynput import keyboard

Explicação: from pynput import keyboard importa o módulo que contém a interface de teclado que usaremos. Ainda não há listener ativo nem eventos sendo observados.

python eventos_teclado.py

Esperado: o terminal volta ao prompt sem erro e sem imprimir mensagens. Esse resultado é normal porque só existe uma importação.

Observado/status: anote a saída real; aprovado somente se a execução terminar sem erro.

Acrescente a função abaixo depois da importação. Neste ponto, o arquivo completo fica assim:

from pynput import keyboard

def ao_pressionar(tecla):
    # Exibe o valor recebido quando o callback for chamado.
    print(f"Pressionada: {tecla}")

Explicação: def define a função; tecla é o parâmetro; a linha indentada exibe o valor recebido. A função está apenas definida — ainda não foi conectada a um listener, então não será chamada por eventos reais.

python eventos_teclado.py

Esperado: o terminal retorna ao prompt sem saída. O teste verifica que a função pode ser definida sem erro; ainda não comprova o recebimento de eventos. O teste funcional será feito quando a função for conectada ao listener.

Observado/status: registre o resultado; aprovado se não houver erro de sintaxe ou importação.

Acrescente o bloco with ao final do arquivo. O conteúdo completo passa a ser:

from pynput import keyboard

def ao_pressionar(tecla):
    # Exibe o valor recebido quando o callback for chamado.
    print(f"Pressionada: {tecla}")

    # ESC oferece uma saída segura desde o primeiro teste ativo.
    if tecla == keyboard.Key.esc:
        print("Encerrando a demonstração.")
        return False

with keyboard.Listener(on_press=ao_pressionar) as listener:
    print("Demonstração ativa. Use somente teclas de teste.")
    print("Pressione ESC para encerrar.")
    listener.join()

Explicação: keyboard.Listener(...) cria o observador; on_press=ao_pressionar passa a função como callback; with gerencia o recurso; listener.join() mantém o programa aguardando enquanto o listener está ativo.

python eventos_teclado.py

Com o terminal visível, pressione e solte poucas teclas fictícias, sem conteúdo sensível. Nesta etapa, o callback trata os pressionamentos. Para encerrar, pressione ESC; a condição está no callback de pressão.

Esperado: cada tecla de teste produz uma linha que começa com Pressionada:. Ao pressionar ESC, aparece Encerrando a demonstração. e o processo volta ao prompt. Se ESC não funcionar, use Ctrl+C no mesmo terminal.

Observado/status: anote as mensagens e confirme que o prompt voltou. Não marque aprovado sem executar.

Agora substitua o conteúdo do arquivo pelo código abaixo, que associa um callback a cada tipo de evento:

from pynput import keyboard

def ao_pressionar(tecla):
    # Exibe o valor recebido no evento de pressão.
    print(f"Pressionada: {tecla}")

    # Por enquanto, ESC encerra quando é pressionada.
    if tecla == keyboard.Key.esc:
        print("Encerrando a demonstração.")
        return False

def ao_soltar(tecla):
    # Exibe o valor recebido no evento de liberação.
    print(f"Solta: {tecla}")

with keyboard.Listener(
    on_press=ao_pressionar,
    on_release=ao_soltar,
) as listener:
    print("Demonstração ativa. Use somente teclas de teste.")
    print("Pressione ESC para encerrar.")
    listener.join()

Explicação: ao_soltar é uma segunda função. O argumento on_release=ao_soltar informa ao listener qual callback chamar quando a tecla for solta. A vírgula separa os argumentos de Listener.

python eventos_teclado.py

Com o terminal visível, pressione e solte algumas teclas fictícias. O encerramento por ESC ainda acontece no evento de pressão: use ESC para parar e aguarde o prompt retornar.

Esperado: para as teclas comuns de teste, aparecem linhas Pressionada: e Solta:. Uma pressão seguida da liberação correspondente deve gerar os dois tipos de mensagem. ESC encerra ao ser pressionada.

Observado/status: registre a saída e marque aprovado, reprovado ou não executado.

Agora vamos fazer o encerramento acontecer quando ESC for solta. Remova de ao_pressionar a condição de parada adicionada no passo anterior e coloque a verificação dentro de ao_soltar, como mostrado abaixo. Assim, o teste também demonstra a diferença entre pressionar e soltar:

def ao_soltar(tecla):
    # Exibe o valor recebido no evento de liberação.
    print(f"Solta: {tecla}")

    # Se ESC for solta, solicita ao listener que pare.
    if tecla == keyboard.Key.esc:
        print("Encerrando a demonstração.")
        return False

Explicação: a condição compara o evento recebido com keyboard.Key.esc. A mensagem torna o encerramento visível. Retornar False neste callback pede ao listener que pare de observar eventos. As três linhas finais precisam estar dentro da função; a condição e o retorno também precisam respeitar a indentação mostrada.

python eventos_teclado.py

Pressione e solte algumas teclas de teste e, por último, pressione e solte ESC.

Esperado: ao soltar ESC, aparece Encerrando a demonstração. e o programa volta ao prompt. Se isso não acontecer, tente Ctrl+C no mesmo terminal; se o prompt não voltar, encerre o terminal do processo. Corrija a condição ou a indentação antes de avançar.

Observado/status: registre o comportamento real.

Atualize o bloco final para informar ao usuário quando a demonstração está ativa e como encerrá-la. O arquivo completo fica assim:

from pynput import keyboard

def ao_pressionar(tecla):
    # Exibe o valor recebido no evento de pressão.
    print(f"Pressionada: {tecla}")

    # Por enquanto, ESC encerra quando é pressionada.
    if tecla == keyboard.Key.esc:
        print("Encerrando a demonstração.")
        return False

def ao_soltar(tecla):
    # Exibe o valor recebido no evento de liberação.
    print(f"Solta: {tecla}")

    # Se ESC for solta, solicita ao listener que pare.
    if tecla == keyboard.Key.esc:
        print("Encerrando a demonstração.")
        return False

with keyboard.Listener(
    on_press=ao_pressionar,
    on_release=ao_soltar,
) as listener:
    print("Demonstração ativa. Use somente teclas de teste.")
    print("Pressione e solte ESC para encerrar.")
    listener.join()

Explicação: as mensagens ficam dentro do bloco with, depois que o listener é configurado. O join() mantém o fluxo principal aguardando. Quando ESC é solta e o callback retorna False, o listener termina e a execução volta ao terminal.

python eventos_teclado.py

Esperado: as duas mensagens de orientação aparecem; os dois callbacks exibem os eventos; ao soltar ESC, a mensagem de encerramento aparece e o processo termina. Se ESC não encerrar, tente Ctrl+C no mesmo terminal. Se o prompt não voltar, encerre o terminal pela interface do VS Code e investigue antes de prosseguir.

Observado/status: registre a saída real e marque aprovado, reprovado ou não executado.

python eventos_teclado.py

Pré-condições: terminal visível, ambiente virtual correto, pynput instalado e arquivo salvo.

Procedimento: confirme as mensagens de orientação; pressione e solte uma tecla comum de teste e uma tecla especial não sensível; depois pressione e solte ESC.

Resultado esperado: mensagens de pressão e soltura aparecem; ESC produz a mensagem de encerramento; o processo termina e o prompt retorna.

Resultado observado: descreva a saída real do terminal. Não copie dados privados.

Critério de aprovação: todos os comportamentos esperados foram observados, o encerramento ocorreu e nenhum dado foi salvo ou transmitido.

Status: ☐ aprovado ☐ reprovado ☐ não executado.

Se falhar: registre o erro, feche o terminal do processo se necessário, corrija o problema e repita o teste completo. Não marque como aprovado com base apenas no resultado esperado.

Para cada passo de 1 a 6, registre:

• Objetivo: o que a alteração deveria demonstrar.
• Comando: python eventos_teclado.py.
• Esperado: o comportamento descrito no passo.
• Observado: o que realmente aconteceu.
• Status: aprovado, reprovado ou não executado.
• Próximo passo: correção necessária ou autorização para continuar.