fls/pitiupi
1
1 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

docs: separar material de TP em docs/tp/

Browse Source 
documentation/ fica neutra (produto); visão TP, tutorial Ping e
checklists de entrega movem para docs/tp/ sem link reverso.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Gabriel Felipe Souza SantosandCursor committed 2026-10-27 21:37:03 -03:00
1 parent de65f3063f
commit aa75cebaaa
19 files changed
+80 -62
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

docs/documentation/00_convencoes.md
+1 -1
View File
@@ -19,7 +19,7 @@ Não descreva funcionalidade futura como se já existisse.
## Código nos exemplos
- Trechos de tutorial são **ilustrativos** quando indicado; o aluno completa o plugin (ver [17_tutorial_ping_aula.md](17_tutorial_ping_aula.md)).
- Trechos de tutorial são **ilustrativos** quando indicado; complete o plugin conforme [10_tutorial_plugin.md](10_tutorial_plugin.md).
- APIs citadas devem existir no núcleo atual (`PluginWorkspace`, `createPlugin(ConnectionManager, PluginWorkspace)`).
## Diagramas
docs/documentation/01_visao_disciplina_e_tp.md
-47
View File
@@ -1,47 +0,0 @@
# Visão da disciplina e trabalho prático
## Papel do Pitiupi
O Pitiupi é uma **plataforma P2P com plugins** usada em Redes de Computadores para:
- Experimentar UDP (multicast/unicast) e TCP na mesma aplicação.
- Observar **presença** de peers (heartbeat) sem servidor central de aplicação.
- Desenvolver **trabalhos individuais ou em grupo** como novos plugins (jogos, ferramentas colaborativas, etc.).
O núcleo fornece rede e GUI; o aluno implementa a lógica no plugin.
## Trabalho típico (plugin)
Cada equipe/aluno entrega um **módulo Java separado** que:
1. Compila para JAR e carrega via `pitiupi/plugins/`.
2. Define mensagens (`extends Message`) e o fluxo entre peers.
3. Integra UI na aba central via `PluginWorkspace` e peer actions na lista lateral.
4. Inclui README do módulo (build + protocolo).
Exemplos de tema: chat temático, tabuleiro (xadrez/damas), compartilhamento de arquivo, quiz síncrono.
## Plugins de referência no repositório
| Módulo | Ideia pedagógica |
| --- | --- |
| `plugins/chat` | Mensagens UDP + UI simples |
| `plugins/screencast` | Payload maior / streaming de imagem |
| `plugins/chat` | Multicast, unicast, TCP e canal TCP privado |
Detalhes: [11_plugins_referencia.md](11_plugins_referencia.md).
## Critérios genéricos (ajustar na disciplina)
| Critério | Indicador |
| --- | --- |
| Funcionalidade | Comportamento correto entre dois+ peers na rede da sala |
| Uso da plataforma | SPI, mensagens, sem “fork” desnecessário do núcleo |
| Build | `ant jar` / `make` reproduzível |
| Documentação | README do plugin + descrição das mensagens |
## Para monitores
- Roteiro de build: [00_quickstart.md](00_quickstart.md).
- Checklist de entrega: [15_testes_e_gate.md](15_testes_e_gate.md).
- Fundamentação para dúvidas de alunos: [16_fundamentacao_redes.md](16_fundamentacao_redes.md).
docs/documentation/02_modulos_do_repositorio.md
+2 -3
View File
@@ -7,8 +7,7 @@ pitiupi/ # clone (este repositório)
├── pitiupi/ # núcleo P2P (executável)
├── plugins/
│ ├── chat/ # chat unificado (UDP/multicast/TCP + TCP privado)
│ ├── screencast/ # compartilhamento de tela
│ └── ping/ # exercício de aula (só doc)
│ └── screencast/ # compartilhamento de tela
└── docs/
```
@@ -25,4 +24,4 @@ pitiupi/ # clone (este repositório)
| `plugins/chat` | `ant jar` | `dist/pitiupi.chat.jar` | `pitiupi.chat.plugin.ChatPlugin` |
| `plugins/screencast` | `ant jar` | `dist/pitiupi.screenCast.jar` | `pitiupi.screenCast.plugin.ScreenCastPlugin` |
Ver [10_tutorial_plugin.md](10_tutorial_plugin.md) e [17_tutorial_ping_aula.md](17_tutorial_ping_aula.md).
Novo módulo: [10_tutorial_plugin.md](10_tutorial_plugin.md).
docs/documentation/04_inicializacao_e_gui.md
+2 -3
View File
@@ -10,9 +10,8 @@ plugins. A comunicação de rede utiliza dois protocolos de transporte: UDP,
empregado principalmente na descoberta e comunicação multicast entre as
instâncias, e TCP, utilizado para comunicação direta e persistente entre peers.
O projeto foi desenvolvido como suporte às práticas da disciplina de Redes de
Computadores, servindo também como base para experimentação de aplicações
distribuídas e desenvolvimento de projetos acadêmicos.
O projeto serve como base para experimentação de aplicações distribuídas e
desenvolvimento de extensões via plugins.
Índice: [README.md](README.md).
docs/documentation/09_sistema_de_plugins.md
+2 -2
View File
@@ -51,7 +51,7 @@ MeusPlugins.plugins.NomeDaClasse
Para serem carregados, os plugins devem estar empacotados como arquivos JAR
e colocados no diretório plugins da aplicação.
O catálogo de build (`plugins.registry.json`) cobre só **chat** e **screencast** no CI. Exercícios (ex. [ping](17_tutorial_ping_aula.md)) ficam fora do repositório — o aluno instala o JAR localmente após `ant jar`.
O catálogo de build (`plugins.registry.json`) cobre **chat** e **screencast** no gate de CI. Outros módulos podem ser buildados localmente e instalados via JAR em `PITIUPI_HOME/plugins` sem entrar no catálogo.
### Carregamento de plugins
@@ -82,7 +82,7 @@ Na `MainShellFrame`, `createPlugin(ConnectionManager, PluginWorkspace)` registra
Em abas de **recebimento** (ex. screencast `view:`), `PluginRoutingPanel.bindReceiveSession` deixa IP e forma de envio somente leitura, refletindo o que o remetente usou.
## Segurança e plugins externos (aula)
## Segurança e plugins de terceiros
- Instale apenas JARs de fontes confiáveis (`PITIUPI_HOME/plugins` ou aba Configurações).
- O núcleo desserializa mensagens de rede com classloader por plugin; mensagens malformadas devem ser ignoradas, mas **não** há sandbox — um JAR malicioso tem o mesmo poder de um programa local.
docs/documentation/10_tutorial_plugin.md
+3 -4
View File
@@ -1,6 +1,6 @@
# Tutorial — criar um plugin
Complementa [09_sistema_de_plugins.md](09_sistema_de_plugins.md). Exercício guiado completo: [17_tutorial_ping_aula.md](17_tutorial_ping_aula.md). Use `plugins/chat` como **modelo de estrutura** (Ant, SPI, painel).
Complementa [09_sistema_de_plugins.md](09_sistema_de_plugins.md). Use `plugins/chat` como **modelo de estrutura** (Ant, SPI, painel).
Os exemplos abaixo são **parciais** — você completa métodos, UI e testes.
@@ -90,9 +90,9 @@ pacote.MeuPlugin
Confirme com `jar tf dist/seu.jar | grep META-INF/services`.
## 5. Catálogo (opcional para TP)
## 5. Catálogo (opcional)
Para build com `./scripts/pitiupi.sh`, adicione entrada em [`plugins.registry.json`](../../plugins.registry.json). Exercícios locais podem instalar só o JAR pela aba **Configurações**.
Para build com `./scripts/pitiupi.sh`, adicione entrada em [`plugins.registry.json`](../../plugins.registry.json). Módulos só locais podem instalar o JAR pela aba **Configurações** sem entrar no catálogo.
## 6. Build e instalação
@@ -119,5 +119,4 @@ cd plugins/meuPlugin && ant jar
## Próximos passos
- [17_tutorial_ping_aula.md](17_tutorial_ping_aula.md) — exercício Ping (RTT, UDP)
- [11_plugins_referencia.md](11_plugins_referencia.md) — chat e screencast
docs/documentation/11_plugins_referencia.md
+3 -8
View File
@@ -46,18 +46,13 @@ Código de entrada: `plugins/screencast/src/pitiupi/screenCast/plugin/ScreenCast
**Limitação:** largura de banda e MTU — frames grandes podem sofrer perda em UDP; adequado para demonstração, não para produção.
## Exercício Ping
## Limitações (não são bugs)
Material em [17_tutorial_ping_aula.md](17_tutorial_ping_aula.md) e pasta `plugins/ping/` (sem código/JAR no repositório). Não entra no `plugins.registry.json` nem no gate CI.
## Limitações didáticas (não são bugs)
Os plugins de referência são **exemplos de sala de aula**, não produtos completos:
Os plugins de referência são **exemplos de demonstração**, não produtos completos:
| Plugin | Inclui | Não inclui (de propósito) |
| --- | --- | --- |
| **chat** | texto, sala geral, unicast/multicast/TCP, TCP privado básico | imagens, moderação, histórico persistente, criptografia |
| **screencast** | stream read-only, avisos de sessão | controle remoto do mouse/teclado, áudio |
| **ping** (exercício do aluno) | chrome de sessão v1 (`PluginRoutingPanel`, abas ↑/↓), RTT, UDP apenas | TCP privado, ICMP do SO, gráficos, SLA |
Para evoluir: copie o padrão (`Plugin` + mensagens + painel na aba) e acrescente features no **seu** JAR — sem inflar o núcleo.
Para evoluir: copie o padrão (`Plugin` + mensagens + painel na aba) e acrescente features no seu JAR — sem inflar o núcleo. Ver [10_tutorial_plugin.md](10_tutorial_plugin.md).
docs/documentation/13_guia_desenvolvimento.md
+1 -1
View File
@@ -13,7 +13,7 @@ Esta documentação descreve a ferramenta Pitiupi neste repositório: build, red
| Tarefa | Ler primeiro |
| --- | --- |
| Novo plugin (aluno) | [10_tutorial_plugin.md](10_tutorial_plugin.md), [11_plugins_referencia.md](11_plugins_referencia.md) |
| Novo plugin | [10_tutorial_plugin.md](10_tutorial_plugin.md), [11_plugins_referencia.md](11_plugins_referencia.md) |
| Bug UDP / multicast | [05_udp_multicast.md](05_udp_multicast.md), [appendix_portas_e_multicast.md](appendix_portas_e_multicast.md) |
| Bug TCP / conexão | [06_tcp_conexoes.md](06_tcp_conexoes.md) |
| Presença / lista de usuários | [08_heartbeat_e_presenca.md](08_heartbeat_e_presenca.md) |
docs/documentation/15_testes_e_gate.md
-8
View File
@@ -50,14 +50,6 @@ Mesma **porta** em ambos (ex. 5000), **mesmos JARs** em `~/pitiupi/plugins` em c
- [ ] Presença e linha **Todos**
- [ ] Troca de mensagens no chat (multicast e, se possível, unicast/TCP)
- [ ] Compartilhamento de tela entre os dois (ambiente com captura de tela funcional — no WSL a captura nativa pode falhar)
- [ ] Plugin Ping do aluno (tutorial [17_tutorial_ping_aula.md](17_tutorial_ping_aula.md)) medindo RTT — recomendado antes da entrega final
## Checklist plugin de aluno
- [ ] JAR em `PITIUPI_HOME/plugins` + SPI correto
- [ ] README do módulo com build e formato das mensagens
- [ ] UI na aba (`PluginWorkspace`), sem `JFrame` principal
- [ ] Demonstração mínima professor ↔ aluno ou aluno ↔ aluno
## Melhorias futuras
docs/documentation/16_fundamentacao_redes.md
+1 -1
View File
@@ -50,7 +50,7 @@ Doc: [09_sistema_de_plugins.md](09_sistema_de_plugins.md).
| Situação | Transporte típico | Motivo |
| --- | --- | --- |
| Lista de usuários / heartbeat | UDP multicast | Todos os peers sem conexão prévia |
| Sala geral (chat, ping broadcast) | UDP multicast ou cópias unicast/TCP conforme combo | Didático: aluno vê diferença na UI |
| Sala geral (chat, broadcast) | UDP multicast ou cópias unicast/TCP conforme combo | Escolha explícita na UI do plugin |
| Mensagem para um IP | UDP unicast ou TCP | Destino explícito |
| Fluxo contínuo (tela, TCP privado chat) | TCP | Fluxo e framing no núcleo |
docs/documentation/17_tutorial_ping_aula.md
-155
View File
@@ -1,155 +0,0 @@
# Tutorial de aula — plugin Ping
Exercício para montar o plugin **mais simples** do Pitiupi: medir **RTT** (tempo de ida e volta) com mensagens `Ping` / `Pong` na rede, igual a um `ping` de laboratório — mas usando o **mesmo mecanismo de plugins** do chat e do screencast.
A solução completa **não** entra no repositório público: o aluno desenvolve em `plugins/ping/` na máquina local (fora do gate CI). Este tutorial traz escopo, trechos e verificações — você implementa o restante.
Índice: [README.md](README.md) · Plugins de referência: [11_plugins_referencia.md](11_plugins_referencia.md).
## O que você vai aprender
| Componente do núcleo | Para que serve no Ping |
| --- | --- |
| `Plugin` + SPI | O Pitiupi descobre seu JAR e chama `createPlugin` |
| `Message` serializável | `PingMessage`, `PongMessage`, `PingStopMessage` |
| `getMessages()` / `receiveMessage` | O núcleo entrega só os tipos que você registrou |
| `MessageDispatcher` | Envia UDP unicast/multicast sem montar socket manual |
| `PluginWorkspace` | Galeria e peer actions abrem a aba central |
| `PeerAction` | Menu ao clicar em um usuário na lista lateral |
| `SessionTabBar` | Abas por peer (passivas ao receber, como no chat) |
## Limitações didáticas (de propósito)
- Não é ICMP do sistema operacional — são mensagens Java na LAN.
- Sem gráficos nem histórico em arquivo.
- Transporte padrão: **UDP unicast** para um peer; multicast só no “ping para todos (uma vez)”.
- Não há moderação, login extra nem criptografia.
## Pré-requisitos
1. Pitiupi abrindo com login (nome + porta).
2. [`09_sistema_de_plugins.md`](09_sistema_de_plugins.md).
3. JDK 17 + Ant.
4. Núcleo compilado: `pitiupi/dist/pitiupi.jar`.
## Passo 1 — Projeto Ant
1. Copie `plugins/chat` para `plugins/ping` (somente na sua máquina).
2. Renomeie o projeto para `pitiupi.ping` e o JAR de saída para `dist/pitiupi.ping.jar`.
3. Classpath de compilação: `../../pitiupi/dist/pitiupi.jar`.
**Verificação:** `ant jar` sem erros.
## Passo 2 — SPI
Arquivo `src/META-INF/services/pitiupi.models.Plugin`:
```
pitiupi.ping.plugin.PingPlugin
```
## Passo 3 — Mensagens
Três classes em `pitiupi.ping.net`, todas estendendo `pitiupi.models.Messages.Message`:
1. **`PingMessage`** — campos: `pingId` (UUID), `sentAtMillis`, `senderName`, `senderIp`, `mode` (`ONCE` ou `CONTINUOUS_TICK`), `sessionId` (para série contínua).
2. **`PongMessage`** — `pingId`, `echoSentAtMillis` (copiado do ping), `responderName`, `responderIp`.
3. **`PingStopMessage`** — `sessionId`, `senderName`, `senderIp` (avisa que o contínuo parou).
Registre em `PingPlugin.getMessages()`:
```java
return List.of(PingMessage.class, PongMessage.class, PingStopMessage.class);
```
**Por quê:** o núcleo só desserializa tipos declarados; evita que outro plugin receba seus bytes por engano.
## Passo 4 — `PingController` (lógica)
Classe em `pitiupi.ping.control` **sem Swing**:
- Ao **enviar** ping: grave `pendingByPingId.put(pingId, sentAtMillis)` e use `MessageDispatcher.send(..., UNICAST_UDP)`.
- Ao **receber** `PingMessage`: responda com `PongMessage` (eco do `sentAtMillis`).
- Ao **receber** `PongMessage`: `rtt = now - pending.remove(pingId)` e notifique a UI.
- **Contínuo:** `javax.swing.Timer` a cada 1 s envia `CONTINUOUS_TICK` com o mesmo `sessionId`.
- **Parar:** cancele o timer local e envie `PingStopMessage` ao peer.
Use `PeerIpv4` e `LocalNetworkInfo.bestLocalIpv4()` para IP legível no Windows.
## Passo 5 — `PingPanel` (UI)
Siga o mesmo chrome do screencast: `PluginSessionWorkspace` + `PluginRoutingPanel` (`PluginKind.PING`, sem TCP privado).
- **Destino e transporte** no topo (IP, forma de envio, banner da sessão).
- Toolbar: **Enviar ping** (uma vez) e **Ping contínuo** (toggle só em abas de peer **↑**; na sala **Todos** só o envio único).
- `SessionTabBar`: sala `Todos ↑`; peers que você abre `Nome ↑`; recebimento passivo `Nome ↓` (`view:<ip>`).
- `+ Nova` / `PeerDraftPanel` para IP manual.
- `JTextArea` monoespaçada por aba; linhas como `[HH:mm:ss] pong ← Alice · RTT 42 ms`.
- Abas **↓**: `bindReceiveSession` — controles de envio desabilitados.
**Não** use `JFrame`. No `PingPlugin`: `bindShellWorkspaceContent(panel)`.
A aba da shell só abre quando o usuário clicar na galeria **Plugins** ou numa peer action (sem enviar ping automaticamente).
## Passo 6 — `PingPlugin`
| Método | Valor |
| --- | --- |
| `getIdentifier()` | `pitiupi.ping` (único na sala) |
| `getDisplayName()` | `Ping na rede` |
`createPlugin(ConnectionManager, PluginWorkspace)`:
1. Crie `PingController` e `PingPanel`.
2. `bindShellWorkspaceContent(panel)`.
3. `installPeerActions(workspace.peerActions())`.
**Peer actions sugeridas:**
| id | Label | Alvo | Comportamento |
| --- | --- | --- | --- |
| `ping.peer` | Enviar ping para esta pessoa | um peer | Abre/foca o plugin e a aba `↑` com o IP — **sem** disparar ping |
| `ping.room` | Abrir ping na sala (Todos) | Todos | Abre a aba sala — **sem** disparar ping |
O envio fica nos botões do painel.
`receiveMessage`: despache para o controller com `SwingUtilities.invokeLater`.
`onShellTabClosed`: pare todos os timers contínuos.
## Passo 7 — Instalar e testar
1. `ant jar` → `dist/pitiupi.ping.jar`.
2. Aba **Configurações** → **Instalar JAR…** (ou copie para `~/pitiupi/plugins/`).
3. **Reinicie** o Pitiupi (obrigatório após mudar plugins).
4. Dois processos no mesmo PC: portas **5000** e **5001**, nomes diferentes.
5. Lista lateral → **Enviar ping para esta pessoa** → aba `↑` com IP; clique **Enviar ping** → RTT no log.
6. Toggle **Ping contínuo** na aba `↑` → linhas a cada ~1 s; desligar o toggle → o outro vê “parou o ping contínuo” na aba `↓`.
7. Com colega na LAN: mesma porta, JAR instalado nos dois.
Instalação usa o mesmo `PluginStore` da aba **Configurações** (`installFromFile` + reinício). O núcleo expõe `pitiupi.tools.PluginStoreCli` para testes sem interface gráfica.
## Passo 8 — Comparar com o chat
O chat usa a mesma ideia de abas de sessão, mas adiciona roteamento TCP privado e HTML. No Ping mantenha **só** UDP e texto em `JTextArea` — ideal para entender o fluxo antes de copiar padrões para um plugin novo.
## Problemas comuns (Ping)
| Sintoma | Diagnóstico |
| --- | --- |
| RTT não aparece | `Pong` sem `pingId` correspondente em `pendingByPingId` |
| Peer não recebe | Tipo não listado em `getMessages()` ou UDP bloqueado |
| `ClassCastException` | Versões diferentes do JAR entre PCs |
| Aba não abre | Esqueceu `bindShellWorkspaceContent` ou peer action só abre UI (envio é no painel) |
Mais geral: [10_tutorial_plugin.md](10_tutorial_plugin.md#problemas-comuns).
## Checklist do aluno
- [ ] SPI e `getIdentifier` únicos
- [ ] Três mensagens registradas
- [ ] RTT calculado no `Pong`
- [ ] Aba passiva `↓` ao receber ping de peer novo (sem roubar foco da shell)
- [ ] Contínuo + parar com aviso ao peer
- [ ] Reinício após instalar JAR
- [ ] Teste com segundo usuário (5001 ou outro PC)
docs/documentation/README.md
+5 -5
View File
@@ -6,10 +6,10 @@
| Área | Arquivos |
| --- | --- |
| **Início** | [00_quickstart](00_quickstart.md), [01_visao_disciplina_e_tp](01_visao_disciplina_e_tp.md), [02_modulos](02_modulos_do_repositorio.md), [03_build](03_build_ant_netbeans.md) |
| **Início** | [00_quickstart](00_quickstart.md), [02_modulos](02_modulos_do_repositorio.md), [03_build](03_build_ant_netbeans.md) |
| **Arquitetura e GUI** | [04_inicializacao_e_gui](04_inicializacao_e_gui.md), [13_guia_desenvolvimento](13_guia_desenvolvimento.md), [14_arquitetura_e_manutencao](14_arquitetura_e_manutencao.md) |
| **Rede** | [05_udp_multicast](05_udp_multicast.md), [06_tcp_conexoes](06_tcp_conexoes.md), [07_mensagens](07_mensagens_e_serializacao.md), [08_heartbeat](08_heartbeat_e_presenca.md), [16_fundamentacao_redes](16_fundamentacao_redes.md), [appendix_portas_e_multicast](appendix_portas_e_multicast.md) |
| **Plugins** | [09_sistema_de_plugins](09_sistema_de_plugins.md), [10_tutorial_plugin](10_tutorial_plugin.md), [17_tutorial_ping_aula](17_tutorial_ping_aula.md), [11_plugins_referencia](11_plugins_referencia.md), [12_transporte_e_peer_actions](12_menus_unicast_multicast.md) |
| **Plugins** | [09_sistema_de_plugins](09_sistema_de_plugins.md), [10_tutorial_plugin](10_tutorial_plugin.md), [11_plugins_referencia](11_plugins_referencia.md), [12_transporte_e_peer_actions](12_menus_unicast_multicast.md) |
| **Qualidade** | [15_testes_e_gate](15_testes_e_gate.md), [engineering_backlog](engineering_backlog.md) |
## Ordem linear (referência)
@@ -17,10 +17,10 @@
| # | Arquivo | Conteúdo |
| --- | --- | --- |
| 0 | [00_quickstart.md](00_quickstart.md) | Build, plugins, duas instâncias |
| 1–3 | 01–03 | Disciplina, módulos, Ant |
| 2–3 | 02–03 | Módulos, Ant |
| 4 | [04_inicializacao_e_gui.md](04_inicializacao_e_gui.md) | Boot, `MainShellFrame`, shell Swing |
| 5–8 | 05–08 | UDP, TCP, mensagens, presença |
| 9–12 | 09–12 | Plugins, tutoriais, transporte na UI |
| 9–12 | 09–12 | Plugins, tutorial genérico, transporte na UI |
| 13–15 | 13–15 | Dev, manutenção, testes |
| 16–17 | 16–17 | Fundamentação redes, exercício Ping |
| 16 | [16_fundamentacao_redes.md](16_fundamentacao_redes.md) | Fundamentação redes ↔ código |
| — | [appendix_portas_e_multicast.md](appendix_portas_e_multicast.md) | Portas, Wi‑Fi, WSL |
docs/documentation/appendix_portas_e_multicast.md
+2 -2
View File
@@ -11,7 +11,7 @@
- Grupo: **`224.0.0.3`** (fixo no código do núcleo).
- Buffer UDP: **256000** bytes (configuração em `SocketUDP`).
Todos os peers na mesma LAN devem usar a **mesma porta** para participar do mesmo “grupo lógico” da aula (portas diferentes = grupos isolados).
Todos os peers na mesma LAN devem usar a **mesma porta** para participar do mesmo grupo lógico de peers (portas diferentes = grupos isolados).
## Mesmo computador
@@ -40,7 +40,7 @@ Ao abrir conversa pela lista de presença, o campo de destino usa **`PeerIpv4`**
## Checklist — dois PCs na mesma Wi‑Fi
1. **Mesma porta no login** (ex.: `5000` nos dois). Portas diferentes isolam a sala.
2. **Configurações → Sua conexão:** IPs na mesma sub-rede (ex. ambos `192.168.0.x` ou `192.168.1.x`). Se um for `172.x` (WSL/Docker) e outro `192.168.x`, o multicast da aula não cruza.
2. **Configurações → Sua conexão:** IPs na mesma sub-rede (ex. ambos `192.168.0.x` ou `192.168.1.x`). Se um for `172.x` (WSL/Docker) e outro `192.168.x`, o multicast entre esses hosts não cruza.
3. **Firewall:** liberar **UDP entrada e saída** na porta do login (Windows Defender / `ufw`).
4. **Roteador:** desativar *isolamento de clientes* / *AP isolation* / Wi‑Fi de visitantes.
5. Aguardar até **~15 s** após abrir os dois apps (heartbeat a cada 5 s).