O bug não aparecia em nenhum notebook. Três de nós abrimos o simulador da IDE, percorremos o fluxo inteiro duas vezes e deu tudo certo. Num Android de dois anos, o mesmo build engasgou na primeira tela e depois pediu uma permissão que o simulador já tinha liberado em silêncio semanas antes. Mesmo commit, mesmo pacote. A única coisa que mudou foi onde ele rodou.

A questão é essa: o emulador não mente de propósito. É um processo de desktop, com CPU de desktop, permissões que você já aprovou e uma única versão do anfitrião, sempre atualizada. Um miniprograma real vive dentro do app de outra pessoa, num aparelho que você nunca segurou, numa versão do anfitrião que você não controla. Desempenho, diálogos de permissão e versão do anfitrião são os três buracos em que tropeçamos sempre, e são sistemáticos, não acidentes.

Onde a diferença aparece de verdade

Comece pelo desempenho. Seu notebook tem ventoinha, está na tomada e a CPU não cai de rendimento numa demo de dois minutos. Um intermediário de três anos cai, sim, e justo quando o minigame já roda faz um tempo e o aparelho esquentou. Já vimos uma tela manter os quadros estáveis no simulador e começar a perder quadros assim que o celular esquentava. O código não mudou; mudou o silício.

Permissões são mais traiçoeiras. No simulador você libera câmera ou localização no primeiro dia e esquece que aquilo existe. Usuários reais negam, bloqueiam o aviso para sempre, revogam tudo pelo sistema e te entregam um estado que seu código nunca viu. A falha quase nunca é um crash: é um mapa em branco, um upload que não faz nada, um botão morto porque um ramo assumiu consentimento.

E tem o anfitrião. Cada um publica sua biblioteca base, e as pessoas não atualizam no seu calendário. Uma API que se comporta de um jeito no runtime atual pode se comportar diferente, ou simplesmente não existir, numa versão de dois anos atrás. Se você só testa contra a mais recente, está testando contra um build que boa parte do público nunca instalou.

DiferençaNo simuladorNo aparelho realComo pegar antes
Orçamento de quadrosCPU de desktop, sem estrangulamentoO intermediário cai quando esquentaPerfilar no celular mais barato que você suporta, depois de dez minutos de uso
Avisos de permissãoLiberados uma vez e esquecidosNegação, bloqueio permanente, revogação do sistemaInstalação limpa com todas as permissões revogadas antes de cada passada
Biblioteca base do anfitriãoSempre a mais recenteUsuários presos em versões de anos atrásFixar uma versão mínima e deixar um aparelho nela
RedeWi-Fi do escritório, sem perda de pacotesSinal fraco, portais cativos, quedas no meio da requisiçãoLimitar a um perfil lento e cortar a conexão durante o carregamento
ArmazenamentoLimpa quando você querLimites de cota e limpezas que você não provocouEncher o cache e medir a partida a frio
EntradaCliques de mouse precisosDedos grandes, deslizes na borda, entalhes da telaPassar o celular para alguém que nunca viu o design

O que custa uma matriz de aparelhos de verdade

Não vamos fingir que a resposta é «teste em aparelhos reais» e pronto. Uma matriz com cinco anfitriões, três versões de sistema e um punhado de celulares baratos é cara de comprar e chata de manter: carregados, atualizados e logados em contas reais. As fazendas de dispositivos na nuvem ajudam, mas não são a mesma coisa que um telefone com conexão instável na mão de alguém, e a conta sobe a cada combinação que você adiciona.

Automação também tem teto. Dá para roteirizar toques e capturas, mas não a chave de permissão do sistema, nem um app anfitrião que se atualiza de madrugada, nem uma notificação que chega no meio do fluxo. Nossa suíte automática cobre bem o caminho feliz e mal os estados esquisitos — exatamente o contrário de onde vivem os bugs de miniprograma. Aprendemos a ler um pipeline verde como sinal de que o óbvio vai bem, não de que aquilo funciona.

E tem problema que só existe quando chega tráfego real. Um rollout gradual do anfitrião, uma esquisitice de rede regional, um modelo que não compramos: isso aparece em releases por fatias e tickets de suporte, não no laboratório. Incomoda, porque significa que você não compra certeza com mais hardware. Só encurta a distância entre publicar algo e perceber que quebrou.

Publique pouco e depois observe

Então paramos de tentar tornar o simulador honesto e passamos a tratá-lo como o que ele é: um lugar rápido para checar lógica, não um lugar para dar o aval. O aval acontece numa matriz pequena que a gente realmente mantém: um aparelho antigo por anfitrião, um fixado na versão mínima da biblioteca base e outro que deixamos de propósito quente e entulhado. Todo o resto sai como release por fatias para um pedaço dos usuários reais, com as rotas de permissão negada e partida a frio instrumentadas antes de ampliar o rollout.

Essa ordem importa mais que a ferramenta. Pegue os bugs de lógica onde iterar é barato, os de aparelho em uns poucos celulares reais, e aceite que a última categoria só aparece em produção. Os times que se dão mal não são os que têm um laboratório modesto, e sim os que acharam que um simulador limpo queria dizer que tinham terminado.

Fontes