Whatsapp number connection

[DanielSilvaol]

Every time I manage to connect correctly with the whatsapp qrcode, but when I try to reconnect to send a message or something, it doesn't return the object with ".registered()" it always ends up coming empty, here's the problem code, is there something wrong? In this case, it returns optionalWhatsapp as false

public Whatsapp executeOnReconnection(UUID id) {
        Optional<WebOptionsBuilder> webOptionsBuilder = Whatsapp.webBuilder().newOptionalConnection(id);
        log.info(String.format("webOptionsBuilder: %s", webOptionsBuilder.isPresent()));
        if (webOptionsBuilder.isPresent()) {
            Optional<Whatsapp> optionalWhatsapp = webOptionsBuilder.get().registered();
            log.info(String.format("optionalWhatsapp: %s", optionalWhatsapp.isPresent()));
            if (optionalWhatsapp.isPresent()) {
                Whatsapp whatsapp = optionalWhatsapp.get();
                whatsapp.addDisconnectedListener(onDisconnectedActions::onDisconnected);
                whatsapp.addNewMessageListener(newMessageActions::onNewMessage);
                whatsapp.reconnect().join();
                return whatsapp;
            }
        }
        throw new RuntimeException("Timeout");
    }

[devPedroFreire]

did you find something about this? I'm having the same problem

[DanielSilvaol]

@pedroheavy então cara, eu faço o seguinte hoje, faço a chamada com o join(), só que salvo o arquivo qrcode, em um servidor, e dai chamo um outro endpoint pra visualizar esse arquivo que foi gerado, dai colocou timeout de 2 minutos para caso ele não seja conectado nesse tempo, ele cancela, mas se conectar ele já finaliza, vou deixar um codigo de exemplo aqui pra tu

WebOptionsBuilder webOptionsBuilder = Whatsapp.webBuilder().newConnection();
        return webOptionsBuilder.unregistered(qr -> {
                    try {
                        String urlQrcode = fileActions.salvarArquivo(HandlerQrCodeUtil.onQrCode(qr));
                        qrcodeActions.salvarNovaUrlDoQrcode(urlQrcode, command.getKey());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                })
                .addLoggedInListener(whatsapp -> qrcodeActions.deletar(command.getKey()))
                .addDisconnectedListener(onDisconnectedActions::onDisconnected)
                .addNewMessageListener(newMessageActions::onNewMessage)
                .connect()
                .join();

String urlQrcode é a url do arquivo, o command.getKey() é o que o front me envia para eu pode ter uma referencia de qual requisição é aquele Qrcode

Segue exemplo de codigo para transformar em file o arquivo Qrcode

public class HandlerQrCodeUtil {

    public static File onQrCode(String qr) throws IOException {
        var matrix = QrHandler.createMatrix(qr, 500, 5);
        var os = new java.io.ByteArrayOutputStream();
        MatrixToImageWriter.writeToStream(matrix, "png", os);
        byte[] bytes = os.toByteArray();
        File file = new File("qrcode.png");
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(bytes);
        fos.flush();
        fos.close();
        return file;
    }
}

[devPedroFreire]

é exatamente como eu to fazendo... tendo que chamar 2 endpoints também. Mas valeu, muito obrigado!

[1neeol]

Boa noite,

@DanielSilvaol, como você implementou um timeout na conexão? Estou implementando thread separada para poder gerenciar várias conexões, mas não encontrei uma forma de para a conexão visto que o .join() é síncrono e não deixa seguir o fluxo quando implementado.

[DanielSilvaol]

@1neeol Boa tarde beleza?

Cara deixa eu entender, você está querendo deixar varios whatsapp conectados e com isso poder enviar a mensagem ou receber de todos, certo?

Olha toda eu salvo alguns dados da aplicação no banco para fazer a reconexão, e ativar os listeners de receber mensagens

@Log4j2
@Component
@RequiredArgsConstructor
public class ReconnectionAction {

    private final WhatsappControlRepository whatsappControlRepository;
    private final ReceiveMessageListener receiveMessageListener;
    private final DisconnectListener disconnectListener;

    public Optional<Whatsapp> executeOnReconnection(WhatsappControl whatsappControl, Boolean addListener) {
        Optional<WebOptionsBuilder> webOptionsBuilder = Whatsapp.webBuilder().newOptionalConnection(whatsappControl.getUuid());
        if (webOptionsBuilder.isPresent()) {
            WebOptionsBuilder webOptionsBuilder1 = webOptionsBuilder.get();
            Optional<Whatsapp> optionalWhatsapp = webOptionsBuilder1.registered();
            if (optionalWhatsapp.isPresent()) {
                optionalWhatsapp.get().connect().whenCompleteAsync((a, b) -> {
                            if (addListener) {
                                a
                                        .addDisconnectedListener(disconnectListener::onDisconnected)
                                        .addNewMessageListener(receiveMessageListener::onNewMessage)
                                        .addMessageStatusListener(receiveMessageListener::onMessageStatus);
                            }


                        }
                ).join();
                return optionalWhatsapp;
            }
        }
        return Optional.empty();
    }


    public void executeOnReconnection() {
        List<WhatsappControl> whatsappControls = whatsappControlRepository.findAllByActiveTrue();
        for (WhatsappControl whatsappControl : whatsappControls) {
            Optional<Whatsapp> whatsappOptional = this.executeOnReconnection(whatsappControl, true);
            if (whatsappOptional.isEmpty()) {
                log.error("[{}] Disconnected", whatsappControl.getNumberPhone().number());
                whatsappControl.setActive(false);
                whatsappControlRepository.save(whatsappControl);
            } else {
                log.info("[{}] Reconnected", whatsappControl.getNumberPhone().number());
            }
        }
    }
}

Dai no caso eu consigo aqui enviar a mensagem sem precisar recriar o listener, se não ele duplica, e com base nesse uuid, eu vou enviando para quem eu quiser, com o numero que esta conectado que eu escolher
O uuid que uso é esse blz? whatsapp.store().uuid()

@Log4j2
@Component
@RequiredArgsConstructor
public class ProcessMessageAction {
    private final ReconnectionAction reconnectionAction;
    private final FindWhatsappAction findWhatsappAction;
    private final SendMessageAction sendMessageAction;
    private final FinishFlowAction finishFlowAction;

    public void process(SendMessageCommand command) {
        WhatsappControl whatsappControl = findWhatsappAction.byPhoneNumber(command.to());
        Optional<Whatsapp> whatsappOptional = reconnectionAction.executeOnReconnection(whatsappControl, false);
        whatsappOptional.ifPresent(whatsapp -> sendMessageAction.sendMessage(whatsapp, command.message(), command.from()));
        finishFlowAction.execute(command.automationExecutorId(), command.position());
    }
}

Qualquer duvida ai, só mandar que ajudo quando possivel! Valeeu, abraço!

[1neeol]

Eu estou utilizando a versão 0.0.7. Nela, quando você vai criar uma instancia, você deve chamar o newConnection(uuid). Por padrão nessa versão, quando se cria um instancia, ele tem um serializer nativo. Então quando chamo novamente passando o mesmo uuid, ele faz a reconexão.

O problema está em um método que tenho que chamar. Estou tendo que chamar o metodo connection().join();

Esse método é síncrono, então so continua o fluxo quando faz a conexão. Questionei inicialmente, pois vi que você conseguiu colocar um timeout nessa conexão, onde, se não conectado em N minutos, ele cancela.

So que nessa versão não estou conseguindo implementar por conta desse método ser sincrono.

Abaixo o exemplo que como estou gerando a conexão:

`package org.example;

import it.auties.whatsapp.api.ClientType;
import it.auties.whatsapp.api.QrHandler;
import it.auties.whatsapp.api.WebHistoryLength;
import it.auties.whatsapp.api.Whatsapp;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.;
import java.util.concurrent.;

public class Main {
private static final Map<UUID, Whatsapp> activeConnections = new ConcurrentHashMap<>();
private static final ExecutorService executor = Executors.newCachedThreadPool();
private static final int CONNECTION_TIMEOUT = 10;

public static void main(String[] args) throws IOException {
    Path path = Path.of("C:\\Temp\\Qrcode");
    Files.createDirectories(path);

    List<UUID> uuids = List.of("6f85a1d0-3b74-43a2-a581-d9422e71e9bd")
            .stream()
            .map(UUID::fromString)
            .toList();

    restoreConnections();

    uuids.forEach(uuid -> {
        executor.submit(() -> connection(uuid));
    });

// Runtime.getRuntime().addShutdownHook(new Thread(() -> {
// System.out.println("Encerrando o ExecutorService...");
// executor.shutdownNow();
// activeConnections.forEach((uuid, whatsapp) -> whatsapp.disconnect());
// }));
}

private static void connection(UUID uuid) {
    while (true) {

        Whatsapp wpp = generateConnection(uuid);

        activeConnections.put(uuid, wpp);
        wpp.awaitDisconnection();
        System.out.printf("Conexão para UUID %s foi desconectada. Tentando reconectar...%n", uuid);
        activeConnections.remove(uuid);

    }
}


    public static Whatsapp generateConnection(UUID uuid){

        return Whatsapp.webBuilder()
                .newConnection(uuid)
                .name("WhatsappBot")
                .historyLength(WebHistoryLength.zero())
                .unregistered(QrHandler.toFile(Path.of("C:\\Temp\\Qrcode\\qrcode-" + uuid + ".png"), QrHandler.ToFileConsumer.toTerminal()))
                .addLoggedInListener(api -> System.out.printf("Conectado: %s para UUID %s%n", api.store().lid(), uuid))
                .addDisconnectedListener(reason -> System.out.printf("Desconectado: %s para UUID %s%n", reason, uuid))
                .addNewChatMessageListener(message -> System.out.printf("Mensagem nova (UUID %s): %s%n", uuid, message.toJson()))
                .connect().join();

    }

    public static void restoreConnections () {
        CustomSerializer customSerializer = new CustomSerializer();

        List<UUID> sessionIds = customSerializer.listIds(ClientType.WEB);

        if (!sessionIds.isEmpty()) {
            sessionIds.forEach(uuid -> {
                executor.submit(() -> connection(uuid));
            });
        }

    }

}`

Tenho que colocar dentro de threads separadas, pois nessa versão é necessário implementar o metodo awaitDisconnection() que tbm é sincrono.

Estou fazendo essa implementação como teste para ver se ela consegue me atender em um determinado projeto. Achei mais interessante serializar a conexão em uma pasta ao inves do banco. Claro, isso em um primeiro momento. Posso mudar depois, caso necessário.

Ps: O codigo que mandei acima sobre é so para ilustrar como penso que vou criar essas instancias.

Ps do Ps: Sou junior do junior(aprendendo) então desculpe qualquer erro grosseiro que esteja vendo no meu codigo rsrs