Como Enviar SMS através da API SMPP usando Javascript/Node.js

A API Short Message Peer-to-Peer (SMPP) é um protocolo robusto e amplamente utilizado para enviar e receber mensagens SMS entre Centros de Serviço de Mensagens Curtas (SMSCs) e Entidades Externas de Mensagens Curtas (ESMEs). Para desenvolvedores que utilizam JavaScript e Node.js, integrar a API SMPP com ferramentas como o Ozeki SMS Gateway permite uma comunicação SMS perfeita. Este guia fornece um tutorial passo a passo sobre como configurar um cliente SMPP, gerenciar conexões, enviar SMS e lidar com relatórios de entrega usando JavaScript e Node.js, completo com exemplos práticos de código.

O protocolo SMPP é uma escolha poderosa para comunicação SMS devido à sua confiabilidade, escalabilidade e suporte para mensagens de alto volume. Ao usar JavaScript e Node.js, os desenvolvedores podem criar aplicações eficientes e orientadas a eventos que se integram perfeitamente com a API SMPP. O pacote smpp, disponível via npm, simplifica as interações de baixo nível do protocolo, permitindo que os desenvolvedores se concentrem na construção de aplicações SMS robustas.

Antes de poder enviar mensagens SMS usando a API SMPP, você precisa configurar uma conta de usuário SMPP e conectar-se a um servidor SMPP, como o fornecido pelo Ozeki SMS Gateway. Esta seção explica como configurar o ambiente e estabelecer uma conexão usando JavaScript.

Passo 1: Instale o Pacote SMPP

Para interagir com o protocolo SMPP, instale o pacote smpp do npm, que fornece uma interface simples para operações da API SMPP em JavaScript.

npm install smpp

Passo 2: Estabeleça uma Conexão

Abaixo está um exemplo de como conectar-se a um servidor SMPP usando Node.js e o pacote smpp. Substitua your.ozeki.server, your_username, e your_password pelos detalhes reais do seu servidor e credenciais.

const smpp = require('smpp');
const session = smpp.connect({
    host: 'your.ozeki.server',
    port: 2775
});

session.on('connect', () => {
    console.log('Conectado ao servidor SMPP');
    
    session.bind_transceiver({
        system_id: 'your_username',
        password: 'your_password'
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log('Conectado com sucesso ao servidor SMPP');
        } else {
            console.error('Falha na conexão:', pdu.command_status);
        }
    });
});

session.on('error', (error) => {
    console.error('Erro de conexão SMPP:', error);
});

Certifique-se de que seu servidor SMPP esteja acessível e que suas credenciais estejam corretas para evitar problemas de conexão. O método bind_transceiver estabelece uma conexão bidirecional para enviar e receber SMS.

Manter uma sessão SMPP ativa requer o envio periódico de mensagens de keep-alive usando o PDU enquire_link. Isso garante que a conexão permaneça aberta e responsiva, especialmente para aplicações de longa duração.

const keepAliveInterval = setInterval(() => {
    session.enquire_link({}, (pdu) => {
        if (pdu.command_status !== 0) {
            console.error('Falha no keep-alive:', pdu.command_status);
        }
    });
}, 30000);

session.on('close', () => {
    clearInterval(keepAliveInterval);
    console.log('Conexão SMPP encerrada');
});

Este código envia um enquire_link a cada 30 segundos para manter a sessão ativa e limpa o intervalo quando a conexão é encerrada.

Uma vez conectado, você pode enviar mensagens SMS usando o PDU submit_sm. A seguinte função em JavaScript demonstra como enviar um SMS com a API SMPP.

function sendSMS(from, to, message) {
    session.submit_sm({
        source_addr: from,
        destination_addr: to,
        short_message: message,
        data_coding: 0, // Codificação GSM 7-bit
        source_addr_ton: 1, // Formato internacional
        source_addr_npi: 1, // Plano de numeração ISDN
        dest_addr_ton: 1,  // Formato internacional
        dest_addr_npi: 1    // Plano de numeração ISDN
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log(`Mensagem enviada com sucesso, message_id: ${pdu.message_id}`);
        } else {
            console.error('Falha no envio da mensagem:', pdu.command_status);
        }
    });
}

sendSMS('12345', '+1234567890', 'Olá do cliente SMPP em Node.js!');

Os parâmetros data_coding, source_addr_ton e dest_addr_ton garantem a codificação adequada da mensagem e a formatação do número de telefone. Ajuste-os conforme suas necessidades.

A API SMPP suporta relatórios de entrega para confirmar se um SMS foi entregue. O código a seguir lida com PDUs deliver_sm para processar notificações de entrega.

session.on('pdu', (pdu) => {
    if (pdu.command === 'deliver_sm') {
        const messageId = pdu.receipted_message_id;
        const status = pdu.message_state;
        
        console.log(`Relatório de entrega para ${messageId}: ${status}`);
        
        session.deliver_sm_resp({
            sequence_number: pdu.sequence_number
        });
    }
});

Este código registra o status de entrega e responde ao servidor para confirmar o recebimento do relatório.

Implementação Completa de Cliente SMPP API em JavaScript (Node.js) para Envio de SMS

Para uma solução pronta para produção, a seguinte classe JavaScript encapsula o gerenciamento de conexão, envio de mensagens e lógica de reconexão para a SMPP API.

const smpp = require('smpp');

class SMPPClient {
    constructor(config) {
        this.config = config;
        this.session = null;
        this.keepAliveInterval = null;
        this.connect();
    }

    connect() {
        this.session = smpp.connect(this.config);
        
        this.session.on('connect', () => {
            console.log('Conectado ao servidor SMPP');
            this.bind();
        });

        this.session.on('error', (error) => {
            console.error('Erro de conexão:', error);
            this.reconnect();
        });

        this.session.on('close', () => {
            console.log('Conexão encerrada');
            this.cleanup();
            this.reconnect();
        });
    }

    bind() {
        this.session.bind_transceiver({
            system_id: this.config.system_id,
            password: this.config.password
        }, (pdu) => {
            if (pdu.command_status === 0) {
                console.log('Conectado com sucesso ao servidor SMPP');
                this.startKeepAlive();
            } else {
                console.error('Falha na conexão:', pdu.command_status);
                this.session.close();
            }
        });
    }

    startKeepAlive() {
        this.keepAliveInterval = setInterval(() => {
            this.session.enquire_link({}, (pdu) => {
                if (pdu.command_status !== 0) {
                    console.error('Falha no keep-alive:', pdu.command_status);
                }
            });
        }, 30000);
    }

    sendSMS(from, to, message) {
        return new Promise((resolve, reject) => {
            this.session.submit_sm({
                source_addr: from,
                destination_addr: to,
                short_message: message,
                data_coding: 0
            }, (pdu) => {
                if (pdu.command_status === 0) {
                    resolve(pdu.message_id);
                } else {
                    reject(new Error(`Erro SMPP: ${pdu.command_status}`));
                }
            });
        });
    }

    cleanup() {
        if (this.keepAliveInterval) {
            clearInterval(this.keepAliveInterval);
            this.keepAliveInterval = null;
        }
    }

    reconnect() {
        this.cleanup();
        setTimeout(() => {
            console.log('Tentando reconectar...');
            this.connect();
        }, 5000);
    }
}

const client = new SMPPClient({
    host: 'your.ozeki.server',
    port: 2775,
    system_id: 'your_username',
    password: 'your_password'
});

client.sendSMS('12345', '+1234567890', 'Olá do cliente SMPP completo!')
    .then(messageId => console.log('ID da mensagem:', messageId))
    .catch(err => console.error('Erro:', err));

Esta implementação inclui tratamento de erros, reconexão automática e envio de mensagens baseado em promessas, tornando-a adequada para ambientes de produção.

• Tratamento de Erros: Implemente um tratamento robusto de erros para gerenciar problemas de rede e erros do servidor.
• Async/Await: Use promessas ou async/await para melhor controle de fluxo em operações assíncronas.
• Enfileiramento de Mensagens: Para envio de SMS em alto volume, implemente uma fila para gerenciar a taxa de transferência.
• Monitoramento de Conexão: Monitore continuamente o estado da conexão e implemente lógica de reconexão automática.
• Codificação de Caracteres: Lide com diferentes codificações de caracteres (ex: GSM 7-bit, UCS-2) para suportar SMS internacionais.

Este guia abrangente mostrou como implementar um cliente SMPP robusto usando JavaScript e Node.js para interagir com a SMPP API e o Ozeki SMS Gateway. Desde a configuração da conexão até o envio de SMS e tratamento de relatórios de entrega, os exemplos fornecidos demonstram aplicações práticas do pacote smpp. Para casos de uso avançados, considere explorar recursos como concatenação de mensagens, esquemas de codificação avançados e registro para aplicações de nível de produção.

Para mais detalhes sobre o protocolo SMPP ou o Ozeki SMS Gateway, visite a documentação oficial ou entre em contato com seu provedor de gateway SMS.