Comment envoyer des SMS via l'API SMPP en utilisant PHP

L'API Short Message Peer-to-Peer (SMPP) est un protocole de télécommunications puissant conçu pour échanger des messages SMS entre des entités homologues, telles que des centres SMS et des applications externes. Ce guide complet montre comment implémenter l'API SMPP en utilisant PHP pour se connecter à la passerelle SMS Ozeki, permettant aux développeurs d'envoyer et de gérer des messages SMS efficacement. Avec des exemples de code PHP détaillés, ce tutoriel couvre la configuration de la connexion, l'envoi de messages, les rapports de livraison et les meilleures pratiques pour créer un client API SMPP robuste.

Comprendre l'API SMPP et son rôle dans la messagerie SMS

L'API SMPP (Short Message Peer-to-Peer) est largement utilisée dans l'industrie des télécommunications pour faciliter la communication SMS à haut volume. Elle permet aux applications de se connecter à une passerelle SMS, comme la passerelle SMS Ozeki, pour envoyer et recevoir des messages de manière fiable. En utilisant PHP, les développeurs peuvent créer des applications évolutives qui interagissent avec l'API SMPP pour gérer les flux de travail SMS. Ce guide utilise la bibliothèque php-smpp, un outil robuste pour implémenter le protocole SMPP en PHP, afin de simplifier les interactions de bas niveau avec le protocole.

Configuration du client PHP SMPP pour envoyer des SMS via l'API SMPP

Pour envoyer des SMS via l'API SMPP, vous devez d'abord serveur SMPP de la passerelle SMS Ozeki. Nous utiliserons la bibliothèque php-smpp qui fournit une implémentation du protocole SMPP :

  1. Installez la bibliothèque php-smpp à l'aide de Composer pour gérer les interactions avec l'API SMPP.
  2. Configurez vos paramètres de connexion, y compris l'hôte, le port, le nom d'utilisateur et le mot de passe fournis par la passerelle SMS Ozeki.
  3. Établissez une connexion au serveur SMPP en utilisant un transport par socket.

Voici comment installer la bibliothèque : 

composer require onlinecity/php-smpp

Exemple de connexion de base pour l'API SMPP en PHP

Le code PHP suivant montre comment établir une connexion à la passerelle SMS Ozeki en utilisant l'API SMPP. Cet exemple utilise la bibliothèque php-smpp pour créer un client, se connecter au serveur et se lier en tant qu'émetteur pour envoyer des messages SMS. 

<?php
require 'vendor/autoload.php';

use Smpp\Client;
use Smpp\Transport\Socket;

$host = 'your.ozeki.server';
$port = 2775;
$username = 'your_username';
$password = 'your_password';

// Créer le transport et le client
$transport = new Socket([$host], $port);
$transport->setRecvTimeout(30000);
$smpp = new Client($transport);

// Se connecter et se lier
$transport->open();
$smpp->bindTransmitter($username, $password);

echo "Connexion au serveur SMPP réussie\n";

// Envoyer un message ici...

// Fermer la connexion
$smpp->close();
?>

Ce code initialise un transport par socket, définit un délai d'attente pour la réception de données et lie le client en tant qu'émetteur en utilisant les identifiants fournis. Une fois connecté, le client est prêt à envoyer des messages SMS via l'API SMPP.

Maintenir la connexion avec PHP via l'API SMPP

Pour assurer une connexion fiable à l'API SMPP, votre application PHP doit envoyer des messages de keep-alive périodiques en utilisant la PDU enquire_link. Cela empêche la connexion de expirer et garantit un fonctionnement continu. Voici un exemple de mise en œuvre d'un mécanisme de keep-alive en PHP. 

function sendKeepAlive($smpp) {
    try {
        $smpp->enquireLink();
        echo "Keep-alive envoyé\n";
    } catch (Exception $e) {
        echo "Échec du keep-alive : " . $e->getMessage() . "\n";
        // Implémenter une logique de reconnexion ici
    }
}

// Envoyer un keep-alive toutes les 30 secondes
$keepAliveInterval = 30;
$lastKeepAlive = time();
while (true) {
    if (time() - $lastKeepAlive >= $keepAliveInterval) {
        sendKeepAlive($smpp);
        $lastKeepAlive = time();
    }
    // Gérer d'autres opérations ici
    sleep(1);
}

Ce script envoie un message keep-alive toutes les 30 secondes et inclut une gestion des erreurs pour gérer les problèmes de connexion. Si un keep-alive échoue, vous pouvez implémenter une logique de reconnexion pour rétablir la connexion à l'API SMPP.

Envoyer des messages SMS avec PHP via l'API SMPP

L'envoi de messages SMS via l'API SMPP en PHP implique la création d'un message SMS avec la PDU submit_sm. L'exemple suivant montre comment envoyer un message en utilisant la bibliothèque php-smpp. 

use Smpp\Address;
use Smpp\SMS;

$from = new Address('12345', SMPP::TON_ALPHANUMERIC);
$to = new Address('+1234567890', SMPP::TON_INTERNATIONAL, SMPP::NPI_ISDN);

$message = new SMS($from, $to, 'Bonjour depuis le client PHP SMPP !');
$message->setDataCoding(SMPP::DATA_CODING_DEFAULT);

try {
    $messageId = $smpp->sendSMS($message);
    echo "Message envoyé avec succès, ID : $messageId\n";
} catch (Exception $e) {
    echo "Échec de l'envoi du message : " . $e->getMessage() . "\n";
}

Dans cet exemple, l'adresse de l'expéditeur est définie comme une chaîne alphanumérique, et le numéro du destinataire utilise un formatage international. Le paramètre DATA_CODING_DEFAULT garantit la compatibilité avec les messages texte standard. La gestion des erreurs permet de capturer et de signaler tout problème lors de l'envoi du message.

Gérer les rapports de livraison avec PHP via l'API SMPP

L'API SMPP prend en charge les rapports de livraison pour suivre l'état des messages envoyés. Pour recevoir ces rapports en PHP, liez votre client en tant que récepteur et traitez les PDU deliver_sm entrantes. Le code suivant montre comment implémenter cette fonctionnalité. 

// D'abord, se lier en tant que récepteur pour recevoir les rapports de livraison
$smpp->bindReceiver($username, $password);

while (true) {
    try {
        $pdu = $smpp->readPDU();
        if ($pdu instanceof DeliverSm) {
            $messageId = $pdu->getReceiptedMessageId();
            $status = $pdu->getMessageStatus();
            
            echo "Rapport de livraison pour $messageId : $status\n";
            
            // Envoyer une réponse
            $smpp->respond($pdu, new DeliverSmResp());
        }
    } catch (Exception $e) {
        echo "Erreur de lecture PDU : " . $e->getMessage() . "\n";
        break;
    }
}

Ce code lie le client en tant que récepteur pour écouter les rapports de livraison, traite les PDU entrantes et envoie des réponses appropriées. Cela garantit que votre application PHP peut suivre efficacement les statuts de livraison des messages.

Client PHP SMPP complet pour envoyer des SMS via l'API SMPP

Ci-dessous se trouve une classe PHP complète qui encapsule les fonctionnalités de l'API SMPP, y compris la gestion des connexions, l'envoi de messages et la logique de reconnexion. Cette implémentation est conçue pour une utilisation en production, avec une gestion robuste des erreurs et une modularité. 

<?php
require 'vendor/autoload.php';

use Smpp\Client;
use Smpp\Transport\Socket;
use Smpp\Address;
use Smpp\SMS;

class SMPPClient {
    private $transport;
    private $smpp;
    private $config;
    private $isConnected = false;
    
    public function __construct($config) {
        $this->config = $config;
        $this->connect();
    }
    
    public function connect() {
        try {
            $this->transport = new Socket([$this->config['host']], $this->config['port']);
            $this->transport->setRecvTimeout(30000);
            $this->smpp = new Client($this->transport);
            $this->transport->open();
            $this->smpp->bindTransceiver(
                $this->config['username'],
                $this->config['password']
            );
            $this->isConnected = true;
            echo "Connecté au serveur SMPP\n";
        } catch (Exception $e) {
            echo "Échec de la connexion : " . $e->getMessage() . "\n";
            $this->reconnect();
        }
    }
    
    public function sendSMS($from, $to, $message) {
        if (!$this->isConnected) {
            throw new Exception("Non connecté au serveur SMPP");
        }
        
        try {
            $fromAddr = new Address($from, SMPP::TON_ALPHANUMERIC);
            $toAddr = new Address($to, SMPP::TON_INTERNATIONAL, SMPP::NPI_ISDN);
            
            $sms = new SMS($fromAddr, $toAddr, $message);
            $sms->setDataCoding(SMPP::DATA_CODING_DEFAULT);
            
            return $this->smpp->sendSMS($sms);
        } catch (Exception $e) {
            $this->isConnected = false;
            throw $e;
        }
    }
    
    public function reconnect() {
        $this->close();
        sleep(5);
        $this->connect();
    }
    
    public function close() {
        if ($this->isConnected) {
            $this->smpp->close();
            $this->isConnected = false;
        }
    }
    
    public function __destruct() {
        $this->close();
    }
}

// Exemple d'utilisation
$config = [
    'host' => 'your.ozeki.server',
    'port' => 2775,
    'username' => 'your_username',
    'password' => 'your_password'
];

$client = new SMPPClient($config);

try {
    $messageId = $client->sendSMS('12345', '+1234567890', 'Bonjour depuis PHP !');
    echo "Message envoyé avec l'ID : $messageId\n";
} catch (Exception $e) {
    echo "Erreur lors de l'envoi du message : " . $e->getMessage() . "\n";
}
?>

Cette classe fournit une implémentation PHP réutilisable de l'API SMPP, avec des méthodes pour se connecter, envoyer des messages, se reconnecter en cas d'échec et nettoyer les ressources. Elle est conçue pour être modulaire et facile à intégrer dans des applications plus grandes.

Meilleures pratiques pour créer un client PHP SMPP

Pour garantir que votre application PHP utilisant l'API SMPP est robuste et évolutive, suivez ces meilleures pratiques :

  • Implémenter une gestion robuste des erreurs : Capturez et gérez les exceptions pour les échecs de connexion, les erreurs d'envoi de messages et les problèmes de traitement des PDU pour assurer la fiabilité.
  • Utiliser des connexions persistantes : Maintenez une seule connexion à l'API SMPP pour réduire la surcharge et améliorer les performances.
  • Implémenter une file d'attente de messages : Pour l'envoi de SMS à haut volume, utilisez une file d'attente pour gérer la livraison des messages et éviter la surcharge du serveur.
  • Surveiller l'état de la connexion : Vérifiez continuellement l'état de la connexion et implémentez une logique de reconnexion automatique pour gérer les perturbations du réseau.
  • Utiliser un processus worker : Exécutez votre client PHP SMPP en tant que démon ou processus worker pour un fonctionnement continu dans les environnements de production.
  • Journaliser l'activité : Implémentez une journalisation pour suivre les événements de connexion, les statuts des messages et les erreurs pour le débogage et la surveillance.

Conclusion

Ce guide complet a montré comment implémenter un client PHP pour l'API SMPP afin d'envoyer et de gérer des messages SMS en utilisant la passerelle SMS Ozeki. En utilisant la bibliothèque php-smpp, les développeurs peuvent gérer les détails de bas niveau du protocole SMPP tout en se concentrant sur la création d'applications robustes. Les exemples de code fournis couvrent la gestion des connexions, l'envoi de messages, la gestion des rapports de livraison et une classe PHP complète pour une utilisation en production. Pour les applications avancées, envisagez d'implémenter des fonctionnalités supplémentaires telles que la file d'attente de messages, une journalisation détaillée et une surveillance pour améliorer la fiabilité et l'évolutivité.

Pour les environnements de production, assurez-vous que votre client PHP SMPP inclut une gestion robuste des erreurs, une surveillance des connexions et une journalisation. L'API SMPP prend en charge des fonctionnalités avancées comme la priorisation des messages et la limitation du débit, qui peuvent être explorées à mesure que les besoins de votre application évoluent.

More information