Como Automatizar Sequências de Cliques em Jogos Mobile Usando Python e ADB

Coletar recompensas diárias em múltiplos aplicativos móveis é uma tarefa comum, mas extremamente repetitiva. Muitos jogos exigem navegar por uma sequência previsível de telas — abrir o menu, esperar o carregamento, clicar no botão de resgate, fechar banners promocionais e confirmar o recebimento. Quando esse processo precisa ser repetido em cinco, dez ou vinte aplicativos diariamente, o tempo acumulado se torna um gargalo operacional desnecessário.

Neste artigo técnico, vamos explorar como transformar essa rotina manual em um fluxo totalmente automatizado e resiliente utilizando Python, o Android Debug Bridge (ADB) e visão computacional leve com OpenCV.

O Problema da Abordagem Tradicional: Coordenadas Fixas

A primeira reação ao tentar automatizar toques no Android é enviar comandos diretos de coordenadas de tela, como adb shell input tap x y. Embora funcione inicialmente em um ambiente estático, essa abordagem quebra com facilidade por três motivos:

1. Variações de Latência: Um carregamento de rede mais lento faz o clique ocorrer antes da tela estar pronta.
2. Resoluções Distintas: Se você alternar entre um smartphone físico e um emulador, as coordenadas perdem a validade.
3. Pop-ups Intercalados: Promoções sazonais ou avisos no jogo alteram a ordem dos elementos.

Para criar um pipeline estável, a automação precisa observar a interface antes de agir.

Arquitetura da Solução: ADB + OpenCV

A solução eficiente combina o controle nativo de baixo nível com validação visual inteligente:

1. Ponte de Comunicação (ADB): Interage com o dispositivo sem exigir modificações (root) no sistema operacional.
2. Captura em Memória: O Python extrai o buffer do display diretamente via ADB, sem salvar arquivos lentos em disco.
3. Reconhecimento de Padrões (Template Matching): O OpenCV localiza o botão visualmente (ex: ícone de ‘Coletar’ ou botão ‘X’) e retorna as coordenadas exatas da tela em tempo real.
4. Despacho do Toque: O comando de clique é emitido nas coordenadas dinâmicas identificadas.

Implementação Prática em Python

Para executar esse fluxo, você precisará dos pacotes opencv-python, numpy e do binário do adb instalado no ambiente.

1. Captura de Tela sem I/O de Disco

Salvar imagens em disco a cada ciclo degrada o desempenho. O ideal é capturar o screenshot diretamente em um array NumPy compatível com o OpenCV:

python
import subprocess
import cv2
import numpy as np

def capturarteladevice(deviceid=None):
cmd = [“adb”] if deviceid:
cmd.extend([“-s”, device_id])
cmd.extend([“exec-out”, “screencap”, “-p”])

processo = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, _ = processo.communicate()

# Decodifica bytes da imagem diretamente para memória
img_array = np.frombuffer(stdout, dtype=np.uint8)
frame = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
return frame

2. Localização Visual Dinâmica com Template Matching

Em vez de depender de coordenadas fixas, comparamos um pequeno recorte do botão alvo com a tela atual:

python
def localizarelemento(frame, templatepath, limiar=0.8):
template = cv2.imread(templatepath, cv2.IMREADCOLOR)
resultado = cv2.matchTemplate(frame, template, cv2.TMCCOEFFNORMED)
, maxval, , maxloc = cv2.minMaxLoc(resultado)

if max_val >= limiar:
    h, w = template.shape[:2]
    centro_x = max_loc[0] + w // 2
    centro_y = max_loc[1] + h // 2
    return (centro_x, centro_y)
return None

3. Execução do Toque e Gestão da Sequência

Com as coordenadas dinâmicas calculadas, enviamos o evento de toque via ADB:

python
import time

def tocar(x, y, deviceid=None):
cmd = [“adb”] if deviceid:
cmd.extend([“-s”, device_id])
cmd.extend([“shell”, “input”, “tap”, str(x), str(y)])
subprocess.run(cmd, check=True)

def executarpassocomespera(templatepath, tempolimite=15, deviceid=None):
inicio = time.time()
while time.time() – inicio < tempolimite:
frame = capturarteladevice(deviceid)
ponto = localizarelemento(frame, templatepath)
if ponto:
tocar(ponto[0], ponto[1], device_id)
return True
time.sleep(1)
return False

Com essa estrutura modular, a automação da sequência se resume a encadear as etapas previsíveis de cada aplicativo:

python
def rotinarecompensadiaria():
print(“Aguardando botão de entrada…”)
executarpassocomespera(“assets/btnrecompensas.png”)

print("Coletando recompensa diária...")
executar_passo_com_espera("assets/btn_resgatar.png")

print("Fechando popup promocional...")
executar_passo_com_espera("assets/btn_fechar.png")

Otimização e Escalabilidade

Como especialista em IA e automação de sistemas, observo com frequência projetos falharem quando passam de um para múltiplos dispositivos simultâneos. Algumas boas práticas garantem a estabilidade em escala:

• Controle Concorrente: Ao gerenciar múltiplos emuladores, utilize threading ou asyncio associando cada worker a um identificador específico (adb -s <device_id>).
• Resiliência a Animações: Adicione um breve jitter aleatório (100 a 300 ms) entre a detecção do elemento e o toque físico para permitir que transições de interface terminem sua renderização.
• Visão Computacional Escalável: Se botões mudarem de escala ou ângulo, algoritmos mais sofisticados como SIFT/ORB ou modelos de detecção de objetos (YOLOv8 nano) podem substituir o template matching clássico mantendo altíssima velocidade de inferência.

Conclusão e Próximos Passos

A automação de interações em aplicativos móveis vai muito além de macros simples. Quando estruturada com visão computacional e engenharia de software sólida em Python, ela se torna uma ferramenta robusta para QA, coleta de dados, testes automatizados e gestão de rotinas diárias.

Se você possui fluxos de trabalho repetitivos, processos de testes móveis ou demandas de automação complexas que exigem robustez e precisão técnica, entre em contato para avaliar uma consultoria e desenvolver uma solução sob medida.