1. Handshake Poignée de main : Cette phase correspond à un unique échange requête/réponse HTTP entre l’initiateur de la connexion pair client et le pair serveur. Cet échange HTTP est spécifique car il utilise la notion de mise à niveau, définie dans la spécification HTTP. Le principe est simple : l’Upgrade HTTP permet au client de communiquer avec le serveur pour lui demander de changer de protocole de communication et ainsi faire en sorte que le client et le serveur utilisent un protocole autre que HTTP pour discuter.

   GET /chat HTTP/1.1
   Host: server.example.com
   Upgrade: websocket
   Connection: Upgrade
   Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
   Origin: http://example.com

   Avec HTTP, une requête du client avec l'en-tête Upgrade indique l'intention du client de demander à ce que le serveur passe à un autre protocole. Avec le protocole WebSocket, la demande de mise à niveau effectuée au serveur contient une clé unique que le serveur retournera altérée comme preuve qu'il a accepté la demande de mise à niveau. Il s'agit d'une démonstration pratique permettant de prouver que le serveur comprend le protocole WebSocket.

   HTTP/1.1 101 WebSocket Protocol Handshake
   Upgrade: websocket
   Connection: Upgrade
   Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

   Le code de statut de réussite est toujours 101. Tout autre code de statut sera interprété comme un refus de mettre à niveau vers le protocole WebSocket. Le serveur concatène la clé reçue avec une chaîne GUID fixe et il calcule le hachage à partir de la chaîne obtenue. La valeur de hachage est ensuite codée en Base64 et retournée au client via l'en-tête Sec-WebSocket-Accept.

   Lorsque la demande de mise à niveau du protocole HTTP vers le protocole Web Socket a été validée par le serveur endpoint, il n’y a plus de communication possible en HTTP, tous les échanges sont réalisés via le protocole WebSocket.
2. Data transfer : Une fois que l'initialisation de la connexion a été faite entre le client et le serveur, ceux-ci sont connectés et appairés ; les deux peuvent envoyer, recevoir des messages et fermer la connexion. Dans le détail, une fois que le handshake est acceptée, la mise en place du protocole WebSocket est donc acquise. Une connexion côté pair serveur est ouverte ainsi que côté pair client, une gestion de callback est activée pour initier la communication. La phase de Data transfer peut alors entrer en jeu, c’est-à-dire que les deux pairs peuvent désormais s'échanger des messages dans une communication bi-directionnelle et full-duplex. À la suite de l'établissement de liaison, le client et le serveur peuvent envoyer des messages librement via le protocole WebSocket. Notez que les messages WebSocket sont asynchrones et qu'une demande d'envoi ne recevra donc pas nécessairement une réponse immédiate, comme avec HTTP. Avec le protocole WebSocket, il est conseillé de réfléchir en termes de messages généraux allant du client vers le serveur, ou inversement, et d'oublier le modèle classique requête/réponse de HTTP.

import javax.websocket.server.ServerEndpoint;
import javax.websocket.OnMessage;

@ServerEndpoint("/echo")
public class ServiceEcho {

     @OnMessage
     public String écho(String message){
        return "Merci pour ton message : " + message;
    }
}

Mise en place du service grâce à l'annotation @ServerEndPoint

À l'image du Service Web REST, il est très facile d'implémenter un Service WebSocket grâce à ce principe d'annotations. Vous devez précicer sur l'annotation @ServerEndPoint l'URI d'accès, ici /echo ou plus simplement echo. Cette Endpoint sera créée et déployée au démarrage du serveur Web.

Comment recevoir les messages du client

Au minimum, pour que le service serve à quelque chose, vous devez également ajouter une méthode dont le nom est à votre libre choix annotée par @OnMessage qui sera automatiquement appelée à chaque fois qu'un client envoie un message. C'est cette méthode qui réceptionne tous les messages de tous les clients à noter qu'un objet de cette classe sera créé pour chacun des clients connectés.

Principe d'utilisation

Ici, la méthode renvoie instantanément au client le message reçu. Ce type de communication est appelée synchrone, puisque la réponse obtenue suit immédiatement la requête. Nous sommes pour l'instant dans la même situation que dans le Service Web REST sauf que le client reste toujours connecté et qu'il peut à tout moment envoyer un nouveau message. Enfin, dans cet exemple, le type de message est pour l'instant textuel.

ws://localhost:8080/ws/echo

Pour communiquer avec le serveur, vous devez donc préciser la bonne URI en employant le protocole WebSocket. La première chose à faire consiste à définir l'emplacement du serveur avec son numéro de service si ce n'est pas le port 80 localhost:8080, le nom de l'application Web ws suivi du service EndPoint echo.

Connexion au service

Ensuite, vous faites une demande de connexion au serveur. Si la demande est acceptée, vous restez connectés tout le temps que vous désirez.

Envoi et réception des messages

Vous pouvez maintenant envoyer autant de messages que vous souhaitez. Vu l'écriture actuelle de notre service rudimentaire, comme son nom l'indique, il renvoi le même message précédé du texte Merci pour ton message : .

Deconnexion du service

Dès que vous ne souhaitez plus rester connecté, il faut en faire une demande explicite au serveur.

import java.io.IOException;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/echo")
public class ServiceEcho {
     
    @OnMessage
    public String écho(String message){
        return "Merci pour ton message : " + message;
    }

    @OnOpen
    public void ouverture(Session session) throws IOException {
        session.getBasicRemote().sendText("Vous êtes connecté");
    }
}

import java.io.IOException;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/echo/{login}")
public class ServiceEcho {
    private String login;
     
    @OnMessage
    public String écho(String message){
         return login + " : " + message;
    }

    @OnOpen
    public void ouverture(Session session, @PathParam("login") String login) throws IOException {
        this.login = login;
        session.getBasicRemote().sendText("Bonjour "+login);
    }
}

import java.io.IOException;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/echo/{login}")
public class ServiceEcho {
   private String login;
   private Session session;
     
    @OnMessage
    public String écho(String message){
        return login + " : " + message;
    }

    @OnOpen
    public void ouverture(Session session, @PathParam("login") String login) throws IOException {
        this.login = login;
        this.session = session;
        session.getBasicRemote().sendText("Bonjour "+login);
        envoyerATous(login + " vient de se connecter");
    }

    @OnClose
    public void fermeture() throws IOException {
        envoyerATous(login + " vient de se déconnecter");
    }
    
    private void envoyerATous(String message) throws IOException {
        for (Session chacun : session.getOpenSessions())
           if (chacun.isOpen() && chacun!=session) chacun.getBasicRemote().sendText(message);
    }
}

Attribut session

De même que j'avais créé un attribut correspondant au login du client, il peut être intéressant de prévoir un attribut permettant de conserver la session actuelle. Du coup les autres méthodes de rappel n'auront plus besoin de prendre en compte un paramètre de type Session, comme c'est le cas avec la nouvelle méthode annotée @OnClose.

Lister l'ensemble des clients actuellement connectés

Comme pour toutes les classes, rien n'empêche de créer ses propres méthodes, indépendemment des méthodes de rappel. Ainsi, la méthode privée va me permettre d'envoyer un message à tous les clients à chaque nouvelle connexion et à chaque nouvelle deconnexion. Pour cela, je me sert encore de l'objet de type Session qui possède la méthode getOpenSessions() et qui renvoie l'ensemble des sessions représentant les différentes connexions avec les clients actuellement connectés.

Envoi ciblé

Remarquez au passage que j'envoie les messages uniquement aux autres clients. Effectivement, je contrôle l'ensemble des sessions avec la session actuellement mémorisé dans l'attribut de la classe.

import java.io.IOException;
import java.util.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/echo/{login}")
public class ServiceEcho {
   private String login;
   private Session session;
     
    @OnMessage
    public String écho(String message){
        return login + " : " + message;
    }

    @OnOpen
    public void ouverture(Session session, @PathParam("login") String login) throws IOException {
        this.login = login;
        this.session = session;
        envoyerATous(login + " vient de se connecter");
        session.getUserProperties().put("login", login);
        listeDesConnectés();
    }

    @OnClose
    public void fermeture() throws IOException {
       envoyerATous(login + " vient de se déconnecter");
       listeDesConnectés();
    }
    
    private void envoyerATous(String message) throws IOException {
        for (Session chacun : session.getOpenSessions())
           if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
    }
    
    private void listeDesConnectés() throws IOException {
       List<string> liste = new ArrayList<>();
       for (Session chacun : session.getOpenSessions())
           liste.add((String) chacun.getUserProperties().get("login"));
       envoyerATous("Connectés : "+liste.toString());
    }
}

import java.io.*;
import java.util.*;
import javax.json.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/chat/{login}")
public class ServiceChat {
   private String login;
   private Session session;
     
    @OnMessage
    public String chat(String requête) throws IOException{
        JsonObject json = Json.createReader(new StringReader(requête)).readObject();
        String cible = json.getString("cible");
        String message = json.getString("message");
        return envoyerMessage(cible, message) ? "Message envoyé" : "Cible inconnue";
    }

    @OnOpen
    public void ouverture(Session session, @PathParam("login") String login) throws IOException {
        this.login = login;
        this.session = session;
        envoyerATous(login + " vient de se connecter");
        session.getUserProperties().put("login", login);
        listeDesConnectés();
    }

    @OnClose
    public void fermeture() throws IOException {
       envoyerATous(login + " vient de se déconnecter");
       listeDesConnectés();
    }
    
    private void envoyerATous(String message) throws IOException {
        for (Session chacun : session.getOpenSessions())
           if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
    }
    
    private void listeDesConnectés() throws IOException {
       List<String> liste = new ArrayList<>();
       for (Session chacun : session.getOpenSessions())
          liste.add((String) chacun.getUserProperties().get("login"));
       envoyerATous("Connectés : "+liste.toString());
    }

    private boolean envoyerMessage(String destinataire, String message) throws IOException {
        for (Session chacun : session.getOpenSessions())
           if (destinataire.equals(chacun.getUserProperties().get("login"))) {
              chacun.getBasicRemote().sendText(login + " > " + message);
              return true;
           }
        return false;
    }
}

Lecture d'une structure JSON

Depuis la version 7 de JEE l'API concernant JSON est maintenant intégré et disponible. Deux classes sont particulièrement adaptées : JsonObject qui permet de récupérer un ensemble d'attributs, comme c'est le cas ici, JsonArray qui prend en compte une collection d'éléments. Vous avez ensuite plusieurs classes qui prennent s'intéressent plus particulièrement aux valeurs proprement dites suivant leur type : JsonValue, JsonString et JsonNumber.

Création d'une structure JSON

Pour la création d'une structure JSON vous devez utiliser d'autres classes respectivement JsonObjectBuilder qui permet de générer un ensemble d'attributs distincts dans une même entité et JsonArrayBuilder qui permet de générer une collection d'éléments.

Gestion des flux d'entrée (ou de sortie)

Toutes les classes que nous venons de voir permettent de récupérer ou de générer une structure au format JSON. Cependant, cette structure vient généralement d'un flux envoyé dans le réseau généralement sous forme de texte. Encode une fois, il existe des classes spécialisées suivant les différentes situations. Nous avons la classe JsonWriter qui permet de générer un flux sous forme de texte au format JSON à partir d'un objet présent en mémoire centrale. La classe JsonReader, et c'est elle qui nous intéresse, permet de faire l'inverse, c'est-à-dire qu'elle retrouve la structure de l'objet à partir d'un flux de texte formaté en JSON.

Localiser le bon flux

Je rappelle que pour récupérer le flot d'octets, nous devons préciser à partir de quelle structure physique nous l'associons : disque dur, réseau, simple texte, etc. Par rapport au sujet qui nous préoccupe, deux classes sortent du lot, InputStream qui permet de récupérer un flot d'octets, et StringReader qui génère un flot de caractères à partir d'une simple chaîne de caractères.

Récupérer chacun des attributs de l'objet

Pour terminer, cette API propose une classe utilitaire Json qui possède un certain nombre de méthodes statiques, comme createReader() qui permet de créer une structure JSON à partir d'un flux de caractères, getString() qui retourne la valeur de l'attribut spécifié en argument sous forme d'une chaîne de caractères, getInt() qui retourne la valeur de l'attribut spécifié en argument sous forme de valeur numérique, etc.

import java.io.*;
import java.util.*;
import javax.inject.Singleton; // ou import javax.ejb.Singleton;
import javax.json.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/chat/{login}")
@Singleton
public class ServiceChat {
    private Map<String, String> messages = new  HashMap<>();
     
    @OnMessage
    public String chat(Session session, String requête) throws IOException{
        JsonObject json = Json.createReader(new StringReader(requête)).readObject();
        String cible = json.getString("cible");
        String message = json.getString("message");
        return envoyerMessage(session, cible, message) ? "Message envoyé" : "Destinataire pas encore connecté";
    }

    @OnOpen
    public void ouverture(Session session, @PathParam("login") String login) throws IOException {
        envoyerATous(session, login + " vient de se connecter");
        session.getUserProperties().put("login", login);
        listeDesConnectés(session);
        if (messages.containsKey(login)) {
           session.getBasicRemote().sendText(messages.get(login));
           messages.remove(login);
        }
    }

    @OnClose
    public void fermeture(Session session) throws IOException {
       envoyerATous(session, session.getUserProperties().get("login") + " vient de se déconnecter");
       listeDesConnectés(session);
    }
    
    private void envoyerATous(Session session, String message) throws IOException {
        for (Session chacun : session.getOpenSessions())
           if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
    }
    
    private void listeDesConnectés(Session session) throws IOException {
       List liste = new ArrayList<>();
       for (Session chacun : session.getOpenSessions())
          liste.add((String) chacun.getUserProperties().get("login"));
       envoyerATous(session, "Connectés : "+liste.toString());
    }

    private boolean envoyerMessage(Session session, String destinataire, String message) throws IOException {
       String login = (String) session.getUserProperties().get("login");
       for (Session chacun : session.getOpenSessions())
           if (destinataire.equals(chacun.getUserProperties().get("login"))) {
              chacun.getBasicRemote().sendText(login + " > " + message);
              return true;
           }
        messages.put(destinataire, login+" > "+message);
        return false;
    }
}

Plus d'attributs personnels associés à chacun des clients

Vu que nous ne disposons plus que d'un seul objet dans le service, contrairement au comportement par défaut, nous ne pouvons plus créer des attributs représentant le login du client ainsi que sa session. Tout enregistrement personnel doit se faire ou travers de la session, grâce à la méthode prévue pour cela, getUserProperties().

Chaque session représente la connection d'un client

Heureusement, nous pouvons communiquer malgré tout à un client en particulier grâce à la session le représentant. Vous remarquez d'ailleurs, que maintenant toutes les méthodes de rappel disposent d'un paramètre supplémentaire de type Session. Nous sommes obligés de rajouter ces paramètres puisqu'il n'est plus possible de mémoriser la session en cours dans un attribut commun. Cela n'aurait pas de sens.

Enregistrement des messages différés

L'attribut messages permet de sauvegarder momentanément les messages dédiées à un client non connecté actuellement. C'est la méthode envoyerMessage() qui enregistre cette information en précisant la cible et le contenu du message. Lorsque un client se connecte, dès l'ouverture, une vérification est faite au niveau de cet attribut messages pour savoir si un message personnel n'est pas actuellement en attente.

import java.io.*;
import java.util.*;
import javax.inject.Singleton;
import javax.json.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/chat/{login}")
@Singleton
public class ServiceChat {
   private Map<String, String> messages = new  HashMap<>();
   private Map<Session, String> sessions = new HashMap<>();
   
   @OnOpen
   public void ouverture(Session session, @PathParam("login") String login) throws IOException {
       envoyerATous(login + " vient de se connecter");
       sessions.put(session, login);
       if (messages.containsKey(login)) {
          session.getBasicRemote().sendText(messages.get(login));
          messages.remove(login);
       }
       envoyerATous("Connectés : "+sessions.values().toString());        
    }
   
    @OnClose
    public void fermeture(Session session) throws IOException {    
       String login = sessions.get(session);
       sessions.remove(session);
       envoyerATous(login + " vient de se déconnecter");
       envoyerATous("Connectés : "+sessions.values().toString());
    }     
     
    @OnMessage
    public String chat(Session session, String requête) throws IOException{
        JsonObject json = Json.createReader(new StringReader(requête)).readObject();
        String cible = json.getString("cible");
        String message = json.getString("message");
        return envoyerMessage(sessions.get(session), cible, message) ? "Message envoyé" : "Destinataire pas encore connecté";
    }
    
    private void envoyerATous(String message) throws IOException {
       for (Session chacun : sessions.keySet())
           chacun.getBasicRemote().sendText(message);
    }

    private boolean envoyerMessage(String login, String destinataire, String message) throws IOException {
       for (Session chacun : sessions.keySet())
         if (destinataire.equals(sessions.get(chacun))) {
              chacun.getBasicRemote().sendText(login + " > " + message);
              return true;
           }
        messages.put(destinataire, login+" > "+message);
        return false;
    }
}

import java.util.*;
import javax.ejb.*;

@Singleton
@Startup
public class Messages {
   private Map<String, String> messages = new  HashMap<>();   
   
   public void stocker(String login, String message) {
      messages.put(login, message);
   }
   
   public boolean rechercher(String login) {
      return messages.containsKey(login);
   }
   
   public String restituer(String login) {
      String message = messages.get(login);
      messages.remove(login);
      return message;
   }
}

import java.io.*;
import java.util.*;
import javax.ejb.*;
import javax.inject.*;
import javax.json.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/chat/{login}")
@Stateful
public class ServiceChat {
   private String login;
   private Session session;
   @Inject // ou @EJB
   private Messages messages;
   
   @OnOpen
   public void ouverture(Session session, @PathParam("login") String login) throws IOException {
      this.login = login;
      this.session = session;
      envoyerATous(login + " vient de se connecter");    
      session.getUserProperties().put("login", login);
      if (messages.rechercher(login))
          session.getBasicRemote().sendText(messages.restituer(login));
       listeDesConnectés();
    }
   
    @OnClose
    public void fermeture() throws IOException {    
       envoyerATous(login + " vient de se déconnecter");
       listeDesConnectés();
    }     
     
    @OnMessage
    public String chat(String requête) throws IOException{
        JsonObject json = Json.createReader(new StringReader(requête)).readObject();
        String cible = json.getString("cible");
        String message = json.getString("message");
        return envoyerMessage(login, cible, message) ? "Message envoyé" : "Destinataire pas encore connecté";
    }
    
    private void envoyerATous(String message) throws IOException {
        for (Session chacun : session.getOpenSessions())
           if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
    }

    private boolean envoyerMessage(String login, String destinataire, String message) throws IOException {
       for (Session chacun : session.getOpenSessions())
           if (destinataire.equals(chacun.getUserProperties().get("login"))) {
              chacun.getBasicRemote().sendText(login + " > " + message);
              return true;
           }
        messages.stocker(destinataire, login+" > "+message);
        return false;
    }
    
    private void listeDesConnectés() throws IOException {
       List<String> liste = new ArrayList<>();
       for (Session chacun : session.getOpenSessions())
          liste.add((String) chacun.getUserProperties().get("login"));
       envoyerATous("Connectés : "+liste.toString());
    }
}

package ws;

import java.io.Serializable;
import java.text.DateFormat;
import java.util.Date;
import javax.persistence.*;

@Entity
@NamedQuery(name="recherche", query="SELECT m FROM Message m WHERE m.destinataire = :destinataire")
public class Message implements Serializable {
   @Id
   private long id;
   private String expéditeur;
   private String destinataire;
   private String message;
   @Temporal(TemporalType.TIMESTAMP)
   private Date dateEnvoi;

   public long getId() {  return id; }

   public String getExpéditeur() {   return expéditeur;  }
   public void setExpéditeur(String expéditeur) {  this.expéditeur = expéditeur;  }

   public String getDestinataire() {  return destinataire;  }
   public void setDestinataire(String destinataire) {  this.destinataire = destinataire;  }

   public String getMessage() { return message;  }
   public void setMessage(String message) {  this.message = message;  }

   public Date getDateEnvoi() {  return dateEnvoi;  }

   public Message() {
      id = System.currentTimeMillis();
      dateEnvoi = new Date(id);
   }

   public Message(String expéditeur, String destinataire, String message) {
      this.expéditeur = expéditeur;
      this.destinataire = destinataire;
      this.message = message;
      id = System.currentTimeMillis();
      dateEnvoi = new Date(id);      
   }

   @Override
   public String toString() {
      String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(dateEnvoi);
      return "["+date+"] "+expéditeur+" > "+message;
   }
}

package ws;

import java.io.*;
import java.util.*;
import javax.ejb.*;
import javax.json.*;
import javax.persistence.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/chat/{login}")
@Stateful
public class ServiceChat {
   private String login;
   private Session session;
   @PersistenceContext
   private EntityManager bd;
   
   @OnOpen
   public void ouverture(Session session, @PathParam("login") String login) throws IOException {
      this.login = login;
      this.session = session;
      envoyerATous(login + " vient de se connecter");
      session.getUserProperties().put("login", login);
      messagesEnAttente();
      listeDesConnectés();     
   }

   @OnClose
   public void fermeture() throws IOException {
     envoyerATous(login + " vient de se déconnecter");
     listeDesConnectés();
   }
         
   @OnMessage
   public String chat(String requête) throws IOException{
      JsonObject json = Json.createReader(new StringReader(requête)).readObject();
      String cible = json.getString("cible");
      String message = json.getString("message");
      return envoyerMessage(cible, message) ? "Message envoyé" : "Destinataire pas encore connecté";
   }
    
   private void envoyerATous(String message) throws IOException {
      for (Session chacun : session.getOpenSessions())
         if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
   }
    
   private void listeDesConnectés() throws IOException {
     List<String> liste = new ArrayList<>();
     for (Session chacun : session.getOpenSessions())
         liste.add((String) chacun.getUserProperties().get("login"));
     envoyerATous("Connectés : "+liste.toString());
   }

   private boolean envoyerMessage(String destinataire, String message) throws IOException {
      for (Session chacun : session.getOpenSessions())
         if (destinataire.equals(chacun.getUserProperties().get("login"))) {
            chacun.getBasicRemote().sendText(login + " > " + message);
            return true;
         }
      bd.persist(new Message(login, destinataire, message));
      return false;
   }
    
   private void messagesEnAttente() throws IOException {
       List<Message> messages = listeDesMessages();
       if (!messages.isEmpty())
          for (Message message : messages) {
              session.getBasicRemote().sendText(message.toString());
              bd.remove(message);
          }
   }
      
   private List<Message> listeDesMessages() {
       Query requête = bd.createNamedQuery("recherche");
       requête.setParameter("destinataire", login);
       return requête.getResultList();
   }
}

package ws;

import java.io.Serializable;
import java.text.DateFormat;
import java.util.Date;
import javax.persistence.*;

@Entity
@NamedQuery(name="recherche", query="SELECT m FROM Message m WHERE m.destinataire = :destinataire")
public class Message implements Serializable {
   @Id
   private long id;
   private String expéditeur;
   private String destinataire;
   private String message;
   @Temporal(TemporalType.TIMESTAMP)
   private Date dateEnvoi;

   public long getId() {  return id; }

   public String getExpéditeur() {   return expéditeur;  }
   public void setExpéditeur(String expéditeur) {  this.expéditeur = expéditeur;  }

   public String getDestinataire() {  return destinataire;  }
   public void setDestinataire(String destinataire) {  this.destinataire = destinataire;  }

   public String getMessage() { return message;  }
   public void setMessage(String message) {  this.message = message;  }

   public Date getDateEnvoi() {  return dateEnvoi;  }

   public Message() {
      id = System.currentTimeMillis();
      dateEnvoi = new Date(id);
   }

   public Message(String expéditeur, String destinataire, String message) {
      this.expéditeur = expéditeur;
      this.destinataire = destinataire;
      this.message = message;
      id = System.currentTimeMillis();
      dateEnvoi = new Date(id);      
   }

   @Override
   public String toString() {
      String date = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(dateEnvoi);
      return "["+date+"] "+expéditeur+" > "+message;
   }
}

package ws;

import java.io.StringReader;
import javax.json.*;
import javax.websocket.*;

public class DécodeurMessage implements Decoder.Text<Message> {

   @Override
   public Message decode(String envoi) throws DecodeException {
      JsonObject json = Json.createReader(new StringReader(envoi)).readObject();
      Message message = new Message();
      message.setDestinataire(json.getString("cible"));
      message.setMessage(json.getString("message"));
      return message;
   }

   @Override
   public boolean willDecode(String envoi) {         
      try{
          Json.createReader(new StringReader(envoi)).read();  return true;
      }
      catch(JsonException e){ return false; }
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {   }
   
}

Interfaces utilisées

Pour créer un décodeur, vous devez mettre en place une nouvelle classe qui implémente l'une des quatre interfaces suivantes : Decoder.Binary<T>, Decoder.BinaryStream<T>, Decoder.Text<T> ou Decoder.TextStream<T> en rapport avec le type de flux, où T représente la classe qui va stocker l'ensemble des informations issues du message envoyé par le client.

Méthodes à implémenter

Comme d'habitude, vous êtes obligés de redéfinir les méthodes intégrées à l'interface. Elles sont au nombre de quatre. Les méthodes init() et destroy() sont rarement utiles ici, leurs contenues sont vierges. La méthode willDecode() permet d'évaluer si le message peut être décodé ici, nous regardons si le message est bien au format JSON . La méthode qui réalise le décodage s'appelle tout simplement decode(). Comme prévu, elle prend comme paramètre un texte de type String qui contient le message envoyé par le client, et retourne le résultat de son décodage en un objet correspondant au type spécifié dans le template dans notre projet c'est l'entité, donc Message.

Décodage

Dans cette méthode decode(), nous retrouvons finalement l'écriture que nous avons déjà mis en oeuvre dans le projet précédent en décomposant la structure du format JSON et nous renseignons les attributs nécessaires pour l'entité, notamment le destinataire et le contenu du message.

package ws;

import javax.websocket.*;

public class EncodeurMessage implements Encoder.Text<Message> {
   
   @Override
   public String encode(Message message) throws EncodeException {
      return message.toString();
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {  }
}

Interfaces utilisées

À l'image du décodeur, pour créer un encodeur, vous devez créer une nouvelle classe qui implémente l'une des quatre interfaces prévues pour cette phase là. Cette fois-ci, il s'agit de : Encoder.Binary<T>, Encoder.BinaryStream<T>, Encoder.Text<T> ou Encoder.TextStream<T>. T représente la classe qui contient l'ensemble des informations issues du WebSocket qui sera ensuite transformé en un message envoyé pour le client concerné.

Méthodes à implémenter

Ces interfaces possèdent également des méthodes, au nombre de trois. Nous retrouvons les méthodes init() et destroy(). La dernière méthode s'appelle, comme on l'imagine encode(). Elle prend comme paramètre un objet du type spécifié dans le template dans notre projet c'est l'entité, donc Message et doit renvoyer un texte formaté ou pas à l'aide des éléments constituant l'objet récupéré.

Encodage

Dans cette méthode encode(), nous utilisons tout simplement les compétences de l'entité, nous faisons juste appel à la méthode toString(). Vu la simplicité du traitement et le peu de lignes de code, nous aurions pu éviter d'utiliser un encodeur. La plupart du temps, nous profitons de cette phase d'encodage pour élaborer un texte formaté, au format JSON par exemple, ce qui justifie l'utilisation d'un encodeur.

package ws;

import java.io.*;
import java.util.*;
import javax.ejb.*;
import javax.persistence.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint(value="/chat/{login}", encoders=EncodeurMessage.class, decoders=DécodeurMessage.class)
@Stateful
public class ServiceChat {
   private String login;
   private Session session;
   @PersistenceContext
   private EntityManager bd;
   
   @OnOpen
   public void ouverture(Session session, @PathParam("login") String login) throws IOException, EncodeException {
      this.login = login;
      this.session = session;
      envoyerATous(login + " vient de se connecter");
      session.getUserProperties().put("login", login);
      messagesEnAttente();
      listeDesConnectés();     
   }

   @OnClose
   public void fermeture() throws IOException {
     envoyerATous(login + " vient de se déconnecter");
     listeDesConnectés();
   }
         
   @OnMessage
   public String chat(Message envoi) throws IOException, EncodeException {
      envoi.setExpéditeur(login);
      return envoyerMessage(envoi) ? "Message envoyé" : "Destinataire pas encore connecté";
   }
    
   private void envoyerATous(String message) throws IOException {
      for (Session chacun : session.getOpenSessions())
         if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
   }
    
   private void listeDesConnectés() throws IOException {
     List<String> liste = new ArrayList<>();
     for (Session chacun : session.getOpenSessions())
         liste.add((String) chacun.getUserProperties().get("login"));
     envoyerATous("Connectés : "+liste.toString());
   }

   private boolean envoyerMessage(Message message) throws IOException, EncodeException {
      for (Session chacun : session.getOpenSessions())
         if (message.getDestinataire().equals(chacun.getUserProperties().get("login"))) {
            chacun.getBasicRemote().sendObject(message);
            return true;
         }
      bd.persist(message);
      return false;
   }
    
   private void messagesEnAttente() throws IOException, EncodeException {
       List<Message> messages = listeDesMessages();
       if (!messages.isEmpty())
          for (Message message : messages) {
              session.getBasicRemote().sendObject(message);
              bd.remove(message);
          }
   }
      
   private List<Message> listeDesMessages() {
       Query requête = bd.createNamedQuery("recherche");
       requête.setParameter("destinataire", login);
       return requête.getResultList();
   }
}

Annotation @ServerEndPoint

La classe du EndPoint doit être au courant du décodeur et de l'encodeur que nous venons de créer. Cela se fait au niveau de l'annotation @ServerEndPoint qui possède des attributs spécifiques decoders et encoders. Remarquez au passage qui sont au pluriels. Effectivement, nous pouvons mettre en oeuvre autant de décodeurs et d'encodeurs que nous le désirons. Remarquez également que l'attribut relatif au chemin de l'URL se nomme value.

Phase de décodage

Remarquez que le paramètre de la méthode de rappel annotée @OnMessage a changé. Il s'agit maintenant d'un objet de type Message qui comporte toutes les informations issues de la phase de décodage. Nous connaissons donc le destinataire et le message qui lui est dédié. Nous rajoutons l'expéditeur qui est connue uniquement par le WebSocket, qui correspond au login fourni durant la phase d'ouverture. Cette méthode se retrouve bien allégé puisque le décodage du message reçu ne s'y trouve plus.

Phase d'encodage

Pour envoyer des informations aux clients, vous ne devez plus vous soucier de la forme du texte à générer puisque toutes les informations sont stockées dans l'entité. C'est l'encodeur qui s'en occupe. Il suffit juste de faire appel à la méthode sendObject() avec, en argument, l'entité que vous avez renseigné. Rien n'empêche malgré tout d'envoyer le texte que vous voulez sans passer par cette phase d'encodage en utilisant tout simplement les méthodes sendText() comme précédemment.

package ws;

import java.io.StringWriter;
import javax.json.*;
import javax.websocket.*;

public class MessagePersonnel implements Encoder.Text<Message> {
   
   @Override
   public String encode(Message message) throws EncodeException {
      StringWriter texte = new StringWriter();
      JsonWriter json = Json.createWriter(texte);
      JsonObjectBuilder réponse = Json.createObjectBuilder();    
      réponse.add("expéditeur", message.getExpéditeur());
      réponse.add("message", message.getMessage());
      réponse.add("date", message.getId());      
      json.writeObject(réponse.build());
      json.close();
      return texte.toString();
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {  }
}

Flux de texte

L'objectif pour cet encodeur est de créer un texte au format JSON. Cette fois-ci, nous devons mettre en place un flux de texte qui servira ensuite à être envoyé au client concerné. Pour cela, nous utilisons la classe StringWriter. Du coup, la génération du texte formaté se fera à l'aide de la classe JsonWriter.

Génération d'un objet prenant en compte les attributs à envoyer

La classe JsonObjectBuilder permet de générer un objet qui va représenter la structure du document JSON. À l'aide de la méthode add(), vous rajouter les différents attributs qui vont constitués la structure.

Formatage

Une fois que la structure est complète, vous générer le texte à l'aide de l'objet de type JsonWriter. N'oublier surtout pas de clôturer le flux de texte. Le contenu du texte se trouve maintenant en mémoire dans l'objet de type StringWriter.

package ws;

import java.io.StringWriter;
import java.util.List;
import javax.json.*;
import javax.websocket.*;

public class ListeConnectés implements Encoder.Text<List<String>> {

   @Override
   public String encode(List<String> logins) throws EncodeException {
      StringWriter texte = new StringWriter();
      JsonWriter json = Json.createWriter(texte);
      JsonObjectBuilder connectés = Json.createObjectBuilder();    
      JsonArrayBuilder liste = Json.createArrayBuilder();
      for (String login : logins) liste.add(login);
      connectés.add("connectés", liste);      
      json.writeObject(connectés.build());
      json.close();
      return texte.toString();
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {   }
}

Choix du type pour l'encodage

Nous pouvons prendre n'importe quelle classe qui sert de base à l'encodage. Ici, l'objectif est de récupérer la liste des clients connectés. Nous avons tout à fait le droit d'utiliser de prendre List<String>. Après tout c'est une classe comme une autre. Nous retrouvons ce choix comme paramètre de la méthode encode().

Donner la liste des logins

Comme pour le premier encodeur, nous passons par la classe JsonObjectBuilder, sauf que cette fois-ci, il sera composé d'un seul élément nommé connectés. La valeur de cet élément correspond à un ensemble représenté par une structure de tableau que nous implémentons au moyen de la classe JsonArrayBuilder. Le contenu de ce tableau correspond à la liste des clients actuellement connectés.

package ws;

import java.io.*;
import java.util.*;
import javax.ejb.*;
import javax.persistence.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint(value="/chat/{login}", 
                encoders = {MessagePersonnel.class, ListeConnectés.class},
                decoders = DécodeurMessage.class)
@Stateful
public class ServiceChat {
   private String login;
   private Session session;
   @PersistenceContext
   private EntityManager bd;
   
   @OnOpen
   public void ouverture(Session session, @PathParam("login") String login) throws IOException, EncodeException {
      this.login = login;
      this.session = session;
      envoyerATous(login + " vient de se connecter");
      session.getUserProperties().put("login", login);
      messagesEnAttente();
      listeDesConnectés();     
   }

   @OnClose
   public void fermeture() throws IOException, EncodeException {
     envoyerATous(login + " vient de se déconnecter");
     listeDesConnectés();
   }
         
   @OnMessage
   public String chat(Message envoi) throws IOException, EncodeException {
      envoi.setExpéditeur(login);
      return envoyerMessage(envoi) ? "Message envoyé" : "Destinataire pas encore connecté";
   }
    
   private void envoyerATous(String message) throws IOException {
      for (Session chacun : session.getOpenSessions())
         if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
   }
    
   private void listeDesConnectés() throws IOException, EncodeException {
     List<String> liste = new ArrayList<>();
     for (Session chacun : session.getOpenSessions())
         liste.add((String) chacun.getUserProperties().get("login"));
     for (Session chacun : session.getOpenSessions())
         if (chacun.isOpen()) chacun.getBasicRemote().sendObject(liste);
   }

   private boolean envoyerMessage(Message message) throws IOException, EncodeException {
      for (Session chacun : session.getOpenSessions())
         if (message.getDestinataire().equals(chacun.getUserProperties().get("login"))) {
            chacun.getBasicRemote().sendObject(message);
            return true;
         }
      bd.persist(message);
      return false;
   }
    
   private void messagesEnAttente() throws IOException, EncodeException {
       List<Message> messages = listeDesMessages();
       if (!messages.isEmpty())
          for (Message message : messages) {
              session.getBasicRemote().sendObject(message);
              bd.remove(message);
          }
   }
      
   private List<Message> listeDesMessages() {
       Query requête = bd.createNamedQuery("recherche");
       requête.setParameter("destinataire", login);
       return requête.getResultList();
   }
}

Anntotation du WebSocket

Dans le même principe, nous devons préciser tous les encodeurs que nous utilisons. Il suffit de donner leurs noms en les entourants cette fois-ci d'accolades.

Appel des bonnes méthodes

Pour choisir le bon encodeur, il suffit de prendre l'objet adéquat lorsque nous appelons la méthode sendObject(), soit avec un argument de type Message, soit avec un argument de type List<String>.

Communication cohérente

Vous remarquez encore une fois qu'il est possible de mélanger les méthodes sendText() et sendObject(). Toutefois, pour le client qui va recevoir les différents messages, il faut qu'il soit capable de les différencier pour permettre leurs interprétations. Nous le verrons lorsque nous construirons notre client, il sera impératif d'avoir systématiquement le même type de format. Si nous commençons avec un format JSON, tous les autres messages devront être dans ce format là.

QT += core gui network websockets

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = WebSocketClient
TEMPLATE = app
CONFIG += c++11

SOURCES += main.cpp principal.cpp
HEADERS += principal.h
FORMS += principal.ui

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include "ui_principal.h"
#include <QtWebSockets/QWebSocket>

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocket webSocket;
    bool estConnecte;
private slots:
    void commuter();
    void envoiMessage();
    void receptionMessage(QString texte);
    void connexion();
    void deconnexion();
private:
    void seConnecter();
};

#endif // PRINCIPAL_H

#include "principal.h"

Principal::Principal(QWidget *parent) :  QMainWindow(parent)
{
    setupUi(this);
    estConnecte = false; 
    connect(&webSocket, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(&webSocket, SIGNAL(connected()), this, SLOT(connexion()));
    connect(&webSocket, SIGNAL(disconnected()), this, SLOT(deconnexion()));
//    connect(&webSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(deconnexion()));
}

void Principal::commuter()
{
    estConnecte = !estConnecte;   
    if (estConnecte) seConnecter();
    else webSocket.close();
}

void Principal::seConnecter()
{
    QString url = "ws://";
    url+=adresse->text();
    url+=":8080/ws/chat/";
    url+=login->text();
    webSocket.open(QUrl(url));
}

void Principal::envoiMessage()
{
    webSocket.sendTextMessage(message->text());
}

void Principal::receptionMessage(QString texte)
{
    reception->append(texte);
}

void Principal::connexion()
{
    reception->append("Connecté au service");
}

void Principal::deconnexion()
{
    reception->append("Déconnecté du service");
}

Méthodes adaptées

La classe QWebSocket possède un certain nombre de méthodes en relation directe avec toute la procédure nécessaire pour communiquer avec un WebSocket. Pour établir la connexion, vous disposez de la méthode open() qui prend pour argument  l'URL respectant le protocole ws ws://192.168.1.30:8080/ws/chat/manu pa exemple. Pour envoyer un message sous forme de texte, il suffit d'utiliser la méthode sendTextMessage(). A contrario, lorsque vous recevez un message textuel venant cette fois-ci du serveur, vous  êtes alertés grâce au signal nommé textMessageReceived(). Enfin, si vous désirez arrêter la communication avec le service, il suffit d'appeler tout simplement la méthode close(). Vous remarquez que le nom des méthodes est assez évocateur et similaires aux annotations ou aux méthodes utilisées par le service.

Gestion événementielle

La librairie Qt utilise, comme les autres librairies graphique, la gestion événementielle. Dans le cas de Qt, l'approche est assez spéciale, elle fonctionne suivant le principe de signaux et de slots. Même si elle est spéciale, cette façon de faire est géniale dans le sens où il est possible de faire communiquer deux objets qui n'ont absolument rien à voir entre eux pas de relation d'héritage, d'agrégation ou d'association.

Écoute du réseau

Dans le cas qui nous préoccupe, la gestion événementielle paraît tout à fait adapté. Lorsque nous demandons par exemple une connexion au service à l'aide de la méthode open() vue ci-dessus, le signal connected() associé à l'objet webSocket est alors activé si la connexion a pu s'établir avec le serveur. Il en est de même avec la déconnexion au moyen du signal deconnected() et de la réception d'un nouveau message venant du service avec le signal textMessageReceived().

Les slots

À chacun de ces signaux est associée une méthode de rappel slot qui sera automatiquement lancée dès que le signal concerné est activé. C'est dans le constructeur que sont établies ces différentes associations. Respectivement, nous disposons  des slots : connexion(), deconnexion() et receptionMessage().

#include "principal.h"
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>

Principal::Principal(QWidget *parent) :  QMainWindow(parent)
{
    setupUi(this);
    estConnecte = false; 
    connect(&webSocket, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(&webSocket, SIGNAL(connected()), this, SLOT(connexion()));
    connect(&webSocket, SIGNAL(disconnected()), this, SLOT(deconnexion()));
    connect(&webSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(deconnexion()));
}

void Principal::commuter()
{
    estConnecte = !estConnecte;   
    if (estConnecte) seConnecter();
    else webSocket.close();
}

void Principal::seConnecter()
{
    QString url = "ws://";
    url+=adresse->text();
    url+=":8080/ws/chat/";
    url+=login->text();
    webSocket.open(QUrl(url));
}

void Principal::envoiMessage()
{
    if (destinataire->text().isEmpty()) reception->append("ATTENTION, il faut un destinataire");
    else {
      QJsonObject json;
      json["cible"] = destinataire->text();
      json["message"] = message->text();
      QJsonDocument document(json);
      webSocket.sendTextMessage(document.toJson());
    }
}

void Principal::receptionMessage(QString texte)
{   
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    if (!document.isObject()) reception->append(texte);
    else {
       QJsonObject json = document.object();
       if (json.contains("expéditeur"))
       {
          QString expediteur = json["expéditeur"].toString();
          QString message = json["message"].toString();
          reception->append(expediteur+" > "+message);
       }
       if (json.contains("connectés"))
       {
          QJsonArray connectes = json["connectés"].toArray();
          logins->clear();
          for (int i=0; i<connectes.count(); i++)
             logins->addItem(connectes[i].toString());
       }
    }
}

void Principal::connexion()
{
    reception->append("Connecté au service");
}

void Principal::deconnexion()
{
    reception->append("Déconnecté du service");
    logins->clear();
}

Objets spécifiques pour le formatage JSON

À l'image de ce que nous avons découvert dans JEE, la librairie Qt dispose d'un certain nombre de classes capables de décoder ou de générer un texte au format JSON. Il existe trois classes fondamentales, QJsonDocument qui permet de récupérer ou de générer un texte ou un flux binaire au format JSON, QJsonObject qui permet de récupérer ou de générer un ensemble d'attributs dans une même entité et QJsonArray> qui permet de récupérer ou de générer une collection d'éléments.

Récupération d'un document JSON

La classe QJsonDocument nous permet de récupérer un texte au format JSON. Pour cela, vous créez un objet de type QJsonDocument et vous faites appel à la méthode statique fromJson() en passant en argument de la méthode le texte reçu par le serveur.

Récupération d'un objet de la structure JSON

Pour récupérer une entité formée d'un ensemble d'attributs, vous utilisez maintenant la classe QJsonObject. Vous créez un objet de cette classe en vous servant de la méthode object() de la classe QJsonDocument. Une fois que l'objet créé, vous allez récupérer successivement chaque attribut de l'entité en utilisant des crochets et en spécifiant le nom de l'attribut sous forme de chaîne de caractères à l'intérieur de ces crochets. Vous devez utiliser ensuite une méthode qui retourne la valeur de l'attribut suivant le type souhaité, ici nous utilisons la méthode toString().

Récupération d'une collection d'éléments

Lorsque vous devez récupérer un ensemble d'entités, vous passez cette fois-ci par la classe QJsonArray. Cette classe dispose d'une méthode count() qui nous permet de connaître le nombre d'élément constituant la collection. Grâce à cela, nous pouvons ainsi parcourir la collection au travers d'une itérative et d'utiliser encore une fois les crochets pour récupérer chaque élément de la collection.

Générer un document JSON

Cette fois-ci, la manoeuvre est inversée. Vous constituez d'abord votre structure soit avec un objet de type QJsonObject ou un objet de type QJsonArray, vous créez ensuite un document de type QJsonDocument en passant l'objet précédent en argument du constructeur et le trou est joué. Il suffit juste de faire appel à la structure JSON en appelant la méthode toJson() de la classe QJsonDocument.

import java.io.Serializable;
import javax.persistence.*;

@Entity
@NamedQuery(name="recherche",  query="SELECT m FROM Message m WHERE m.destinataire = :destinataire")
public class Message implements Serializable {
   @Id
   private long id;
   private String expéditeur;
   private String destinataire;

   public long getId() {  return id; }

   public String getExpéditeur() {   return expéditeur;  }
   public void setExpéditeur(String expéditeur) {  this.expéditeur = expéditeur;  }

   public String getDestinataire() {  return destinataire;  }
   public void setDestinataire(String destinataire) {  this.destinataire = destinataire;  }

   public Message() {  id = System.currentTimeMillis();  }

   public Message(String expéditeur, String destinataire, String nomFichier) {
      this.expéditeur = expéditeur;
      this.destinataire = destinataire;
      id = System.currentTimeMillis();   
   }
}

import java.io.StringReader;
import javax.json.*;
import javax.websocket.*;

public class DécodeurMessage implements Decoder.Text<Message> {

   @Override
   public Message decode(String envoi) throws DecodeException {
      JsonObject json = Json.createReader(new StringReader(envoi)).readObject();
      Message message = new Message();
      message.setDestinataire(json.getString("cible"));
      return message;
   }

   @Override
   public boolean willDecode(String envoi) {         
      try{
          Json.createReader(new StringReader(envoi)).read();  return true;
      }
      catch(JsonException e){ return false; }
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {   }   
}

import java.io.StringWriter;
import javax.json.*;
import javax.websocket.*;

public class MessagePersonnel implements Encoder.Text<Message> {
   
   @Override
   public String encode(Message message) throws EncodeException {
      StringWriter texte = new StringWriter();
      JsonWriter json = Json.createWriter(texte);
      JsonObjectBuilder réponse = Json.createObjectBuilder();    
      réponse.add("expéditeur", message.getExpéditeur());
      json.writeObject(réponse.build());
      json.close();
      return texte.toString();
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {  }
}

import java.io.StringWriter;
import java.util.List;
import javax.json.*;
import javax.websocket.*;

public class ListeConnectés implements Encoder.Text<List<String>> {

   @Override
   public String encode(List<String> logins) throws EncodeException {
      StringWriter texte = new StringWriter();
      JsonWriter json = Json.createWriter(texte);
      JsonObjectBuilder connectés = Json.createObjectBuilder();    
      JsonArrayBuilder liste = Json.createArrayBuilder();
      for (String login : logins) liste.add(login);
      connectés.add("connectés", liste);      
      json.writeObject(connectés.build());
      json.close();
      return texte.toString();
   }

   @Override
   public void init(EndpointConfig config) {   }

   @Override
   public void destroy() {   }
}

import java.io.*;
import java.nio.ByteBuffer;
import java.util.*;
import javax.ejb.*;
import javax.persistence.*;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint(value="/photos/{login}",  
                encoders = {ListeConnectés.class, MessagePersonnel.class}, 
                decoders = DécodeurMessage.class)
@Stateful
public class ServicePhotos {
   private String login;
   private Session session;
   private Message message;
   private final String répertoire = "/home/manu/Images/";
   @PersistenceContext
   private EntityManager bd;
   
   @OnOpen
   public void ouverture(Session session, @PathParam("login") String login) throws IOException, EncodeException {
      this.login = login;
      this.session = session;
      envoyerATous(login + " vient de se connecter");
      session.getUserProperties().put("login", login);
      photosEnAttente();
      listeDesConnectés();     
   }

   @OnClose
   public void fermeture() throws IOException, EncodeException {
     envoyerATous(login + " vient de se déconnecter");
     listeDesConnectés();
   }
         
   @OnMessage
   public void alerte(Message envoi) {
      envoi.setExpéditeur(login);
      message = envoi;
   }
   
   @OnMessage
   public String réceptionPhoto(ByteBuffer photo) throws IOException, EncodeException {
      return envoyerPhoto(photo) ? "Photo envoyée" : "Destinataire pas encore connecté";
   }
    
   private void envoyerATous(String message) throws IOException, EncodeException {
      for (Session chacun : session.getOpenSessions())
         if (chacun.isOpen()) chacun.getBasicRemote().sendText(message);
   }
    
   private void listeDesConnectés() throws IOException, EncodeException {
     List<String> liste = new ArrayList<>();
     for (Session chacun : session.getOpenSessions())
         liste.add((String) chacun.getUserProperties().get("login"));
     for (Session chacun : session.getOpenSessions())
         if (chacun.isOpen()) chacun.getBasicRemote().sendObject(liste);
   }

   private boolean envoyerPhoto(ByteBuffer photo) throws IOException, EncodeException {
      for (Session chacun : session.getOpenSessions())
         if (message.getDestinataire().equals(chacun.getUserProperties().get("login"))) {
            chacun.getBasicRemote().sendObject(message);
            chacun.getBasicRemote().sendBinary(photo);
            return true;
         }
      FileOutputStream fichier = new FileOutputStream(répertoire+message.getId());
      fichier.write(photo.array());
      fichier.close();
      bd.persist(message);
      return false;
   }
    
   private void photosEnAttente() throws IOException, EncodeException {
       List<Message> messages = listeDesMessages();
       if (!messages.isEmpty())
          for (Message message : messages) {
              session.getBasicRemote().sendObject(message);
              bd.remove(message);
              File fichier = new File(répertoire+message.getId());
              byte[] octets = new byte[(int)fichier.length()];
              FileInputStream flux = new FileInputStream(fichier);
              flux.read(octets);
              flux.close();
              fichier.delete();
              ByteBuffer photo = ByteBuffer.wrap(octets);
              session.getBasicRemote().sendBinary(photo);
          }
   }
      
   private List<Message> listeDesMessages() {
       Query requête = bd.createNamedQuery("recherche");
       requête.setParameter("destinataire", login);
       return requête.getResultList();
   }
}

Nouvel attribut dans la classe

Vous remarquez la précense d'un nouvel attribut nommé message qui correspond à l'entité Message. Il va nous servir à mémoriser temporairement la prise en compte d'une nouvelle photo. En effet, lorsqu'un client désire envoyer une photo à un autre client, le transfert se déroule en deux phases. D'une part, le client envoi un message précisant le destinataire de la photo, et ensuite il envoi le flux d'octets correspondant à l'image à transmettre. Il est nécessaire de mémoriser le destinataire au travers de cet attribut message pour savoir à qui envoyer la photo.

Deux types de message

Vous remarquez dans le code que nous disposons de deux méthodes annotées @OnMessage. La première nommée alerte() va nous servir à connaître le destinataire de la photo. Cette méthode doit être appelée en premier pour enregistrer le nom du destinataire au travers de l'attribut message. La deuxième nommée réceptionPhoto(), comme son nom l'indique, permet de récolter l'ensemble de la photo grâce au paramètre de type ByteBuffer. Cette deuxième méthode appelle à son tour la méthode envoyerPhoto() à la place de envoyerMessage() qui a changé son type d'argument.

La méthode envoyerPhoto()

Cette méthode vérifie, grâce à l'attribut message, si le destinataire est déjà connecté. Si c'est le cas, le message est d'abord envoyer au client en passant par la phase d'encodage afin de connaître l'expéditeur de la photo, ceci au moyen de la méthode connue sendObject(). Ensuite, c'est au tour de la photo, grâce au paramètre de type ByteBuffer, et en utilisant la nouvelle méthode sendBinary().Si le destinataire n'est pas encore présent, nous devons enregistrer la photo dans un fichier temporaire dont le nom correspond à l'identifiant de l'entité. Nous enregistrons ensuite l'entité dans la base de données comment avant afin de pouvoir envoyer ultérieurement la photo en attente lorsque le destinataire se connectera enfin.

La méthode photosEnAttente()

Dans cette méthode, nous faisons la procédure inverse. Nous vérifions si le client qui est en train de se connecté ne dispose pas de photos en attente. Si c'est le cas, comme au préalable, nous envoyons d'abord le message, au moyen de la méthode sendObject(), pour indiquer quel est l'expéditeur et nous envoyons ensuite la photo au moyen de la méthode sendBinary(). Durant cette phase, il faut penser, d'une part à supprimer l'enregistrement dans la base de données, mais également à supprimer le fichier photo, pour que ces informations temporaires ne soit plus présentes.

#ifndef IMAGE_H
#define IMAGE_H

#include <QWidget>

class Image : public QWidget
{
    Q_OBJECT
public:
    explicit Image(QWidget *parent = 0) : QWidget(parent) {}
private slots:
    void chargerPhoto();
    void sauverPhoto();
protected:
    void paintEvent(QPaintEvent *) override;
public:
    void chargerPhoto(const QByteArray &octets);
    QByteArray getOctets()  { return octets; }
private:
    QImage photo;
    QByteArray octets;
};

#endif // IMAGE_H

#include "image.h"

#include <QFileDialog>
#include <QPainter>
#include <QRect>
#include <QFile>

void Image::chargerPhoto()
{
    QString nom = QFileDialog::getOpenFileName(this, "Choisissez votre photo", "", "Images (*.jpeg *.jpg)");
    if (!nom.isEmpty())
    {
        QFile fichier(nom);
        fichier.open(QIODevice::ReadOnly);
        octets = fichier.readAll();
        photo.loadFromData(octets);
        update();
    }
}

void Image::chargerPhoto(const QByteArray &octets)
{
    photo.loadFromData(this->octets = octets);
    update();
}

void Image::sauverPhoto()
{
    if (!photo.isNull())
    {
        QString nom = QFileDialog::getSaveFileName(this, "Sauvegardez la photo");
        if (!nom.isEmpty())
        {
            QFile fichier(nom);
            fichier.open(QIODevice::WriteOnly);
            fichier.write(octets);
        }
    }
}

void Image::paintEvent(QPaintEvent *)
{
    if (!photo.isNull())
    {
        QPainter dessin(this);
        double ratio = (double) photo.width() / photo.height();
        int largeur = width();
        int hauteur = width() / ratio;
        QRect cadrage(0, 0, largeur, hauteur);
        dessin.drawImage(cadrage, photo, photo.rect());
    }
}

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include "ui_principal.h"
#include <QtWebSockets/QWebSocket>

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocket webSocket;
    bool estConnecte;
private slots:
    void commuter();
    void envoiMessage();
    void receptionMessage(const QString &texte);
    void receptionPhoto(const QByteArray &octets);
    void connexion();
    void deconnexion();
private:
    void seConnecter();
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>

Principal::Principal(QWidget *parent) :  QMainWindow(parent)
{
    setupUi(this);
    estConnecte = false; 
    connect(&webSocket, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(&webSocket, SIGNAL(binaryMessageReceived(QByteArray)), this, SLOT(receptionPhoto(QByteArray)));
    connect(&webSocket, SIGNAL(connected()), this, SLOT(connexion()));
    connect(&webSocket, SIGNAL(disconnected()), this, SLOT(deconnexion()));
    connect(&webSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(deconnexion()));
}

void Principal::commuter()
{
    estConnecte = !estConnecte;   
    if (estConnecte) seConnecter();
    else webSocket.close();
}

void Principal::seConnecter()
{
    QString url = "ws://";
    url+=adresse->text();
    url+=":8080/ws/photos/";
    url+=login->text();
    webSocket.open(QUrl(url));
}

void Principal::envoiMessage()
{
    if (destinataire->text().isEmpty()) reception->append("ATTENTION, il faut un destinataire");
    else {
      QJsonObject json;
      json["cible"] = destinataire->text();
      QJsonDocument document(json);
      webSocket.sendTextMessage(document.toJson());
      webSocket.sendBinaryMessage(photo->getOctets());
    }
}

void Principal::receptionMessage(const QString &texte)
{   
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    if (!document.isObject()) reception->append(texte);
    else {
       QJsonObject json = document.object();
       if (json.contains("expéditeur"))
       {
          QString expediteur = json["expéditeur"].toString();
          reception->append(expediteur+" envoie une photo");
       }
       if (json.contains("connectés"))
       {
          QJsonArray connectes = json["connectés"].toArray();
          logins->clear();
          for (int i=0; i<connectes.count(); i++)
             logins->addItem(connectes[i].toString());
       }
    }
}

void Principal::receptionPhoto(const QByteArray &octets)
{
    photo->chargerPhoto(octets);
}

void Principal::connexion()
{
    reception->append("Connecté au service");
}

void Principal::deconnexion()
{
    reception->append("Déconnecté du service");
    logins->clear();
}

Phase de construction

Nous devons rajouter une nouvelle connexion. En effet, le signal binaryMessageReceived() apparaîtra lorsqu'une photo sera envoyée depuis le serveur. Elle est rattachée au slot receptionPhoto() que nous venons de déclarer.

La méthode envoiMessage()

Cette méthode a subit une modification par rapport au projet précédent. Comme prévu dans le service, elle se déroule en deux phases. Il est nécessaire d'envoyer maintenant uniquement le destinataire de la photo au format JSON. Tout de suite après, nous envoyons la suite d'octets correspondant à l'image.

La méthode receptionMessage()

Cette méthode subit une petite modification, juste pour signaler qu'une photo va être envoyée avec le nom de l'expéditeur.

La méthode receptionPhoto()

Comme son nom l'indique, c'est cette méthode qui récupère le flux d'octets correspondant à la photo envoyée par un autre client par l'intermédiaire du service. Cette méthode envoie tout simplement ce flux d'octets à l'objet photo issu de la classe Image que nous avons créée préalablement.

import java.io.IOException;
import javax.websocket.*;
import javax.websocket.server.*;

@ServerEndpoint("/echo/{login}")
public class ServiceEcho {
    private String login;
     
    @OnMessage
    public String écho(String message){
         return login + " : " + message;
    }

    @OnOpen
    public void ouverture(Session session, @PathParam("login") String login) throws IOException {
        this.login = login;
        session.getBasicRemote().sendText("Bonjour "+login);
    }
}

#-------------------------------------------------
#
# Project created by QtCreator 2014-06-08T09:40:14
#
#-------------------------------------------------

QT       += core gui websockets
CONFIG   += c++11

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET   = WebSocketServeur
TEMPLATE = app

SOURCES  += main.cpp  principal.cpp
HEADERS  += principal.h
FORMS    += principal.ui

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
#include "ui_principal.h"
using namespace std;

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
public slots:
    void demarrer(bool etat);
    void nouvelleConnexion();
    void receptionMessage(const QString &message);
    void deconnexion();
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QUrl>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("echo", QWebSocketServer::NonSecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
}

void Principal::demarrer(bool etat)
{
    if (etat) {
        if (service.listen(QHostAddress::Any, 8080))
           log->append("Lancement du service");
        else log->append("Problème de connexion");
        bouton->setText("Arrêter service");
    }
    else {
        service.close();
        log->append("Arrêt du service");
        bouton->setText("Démarrer service");
    }
}

void Principal::nouvelleConnexion()
{    
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    log->append(nom+" vient de se connecter");
    connectes[client] = nom;
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &message)
{
    QWebSocket *client = (QWebSocket *) sender();
    QString repondre = connectes[client] + " > "+message;
    client->sendTextMessage(repondre);
    log->append(repondre);
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    log->append(connectes[client] + " vient de se déconnecter");
    connectes.erase(client);
}

Le code source C++ est plus conséquent que l'équivalent en code Java

Lorsque vous regardez le source Java correspondant et l'implémentation de cette classe en C++, vous vous dites que la différence est énorme. Comme précisée en introduction, le problème vient du fait que nous n'avons pas de serveur d'applications. Vous devez donc vous préoccuper de gérer l'ensemble des sessions de tous les clients, la gestion événementielle pour la prise en compte des méthodes de rappel, etc. Ceci dit, lorsque nous proposerons des sujets plus conséquents, nous n'aurons pas beaucoup plus de code à rajouter. C'est finalement l'ossature minimale pour un bon fonctionnement.

Construction de lobjet service

Durant la phase de création d'un objet de type QWebSocketServer vous devez lui associer un nom logique qui correspond au service qui sera utilisé lors du processus handshake du protocole HTTP. C'est aussi durant cette phase que vous devez préciser si l'échange des messages se fait en mode sécurisé ou pas, soit donc avec le protocole ws:// ou le protocole wss://.

Gestion des nouvelles connexions

Dans Qt, les méthodes de rappel lancées automatiquement ne se font pas à l'aide d'annotations, comme c'est le cas avec JEE. Je le rappelle, dans le monde de Qt, la gestion des différents événements venant du réseau ouverture de connexion, fermeture, envoi de messages, etc. se fait avec le principe des signaux en relation avec des slots. Cela se traduit par l'utilisation de la méthode connect(). Toujours durant cette phase de construction, nous prévoyons le lancement automatique de la méthode nouvelleConnexion() à chaque fois qu'un nouveau client se connecte à ce service.

Démarrer ou arrêter le service

L'IHM comporte un seul bouton qui change d'intitulé pour démarrer ou pour arrêter le service. Contrairement aux serveurs d'applications, le service n'est pas actif dès le départ. Il faut le demander explicitement grâce à la méthode listen(). Vous devez alors préciser le mode d'écoute IPv4, IPv6, Localhost, etc. ainsi que le numéro de port. Dans notre cas, nous prenons toutes les requêtes et le numéro de service est le 8080. Pour arrêter le service, nous retrouvons la méthode classique close().

Point de connexion représentant le client - méthode nouvelleConnexion()

Dès que le service est démarré et dès qu'un nouveau client se connecte, vous devez établir une connexion permanente avec lui. Comme nous l'avons déjà vu, cela se fait au moyen d'un objet de la classe QWebSocket. Pour récupérer ce point de connexion particulier, vous devez appeler la méthode nextPendingConnexion() de la classe QWebSocketServer. Grâce à ce point de connexion, et donc grâce à cette classe QWebSocket, vous êtes à même de récupérer un certain nombre d'informations, notamment la partie path de l'URL bien entendu, ici aussi nous n'avons pas d'annotations spécifiques. Avec ce point de connexion, nous pouvons tout de suite envoyer un message de bienvenue au client, grâce à la méthode sendTextMessage() que nous avons déjà utilisé.

Sauvegarde du point de connexion et gestion des événements associés à chaque client - méthode nouvelleConnexion()

Si vous désirez recevoir des messages du client, il faut à tout prix conserver son point de connexion, ce que nous faisons à l'aide de notre map en lui associant son nom de login. Ensuite, il faut mettre en place la gestion événementielle qui nous permettra de récupérer chacun des messages que ce client particulier enverra. De la même façon, il faut se préoccuper de la déconnexion de ce client pour libérer la ressource associée. C'est pour ces raisons que nous utilisons de nouveau deux fois la méthode connect() pour chaque client, les méthodes de rappel sont respectivement receptionMessage() et deconnexion().

Réception des messages

À chaque fois qu'un nouveau message arrive au service, c'est donc la méthode receptionMessage() qui est sollicité. Toutes les classes de la librairie Qt possèdent la méthode sender() issue de la classe de base QObject qui renvoie un pointeur sur l'objet qui a envoyé le signal événement. Dans notre cas, c'est l'objet de type QWebSocket représentant le client qui a provoqué l'appel de la méthode receptionMessage(). Il suffit de récupérer le nom du login du client correspondant et de répondre immédiatement au client avec la méthode sendTextMessage().

Déconnexion du client

La méthode deconnexion() gère l'événement qui prend en compte la fin de connexion du client. Il faut alors retirer le point de connexion correspondant à ce client de la map et détruire l'objet QWebObjet qui ne sera alors plus utile, ce que fait la méthode deleteLater().

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
#include "ui_principal.h"
using namespace std;

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
public slots:
    void demarrer(bool etat);
    void nouvelleConnexion();
    void receptionMessage(const QString &message);
    void deconnexion();
private:
    void envoyerATous(const QString &message);
    void listeDesConnectes();
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QUrl>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("echo", QWebSocketServer::NonSecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
}

void Principal::demarrer(bool etat)
{
    if (etat) {
        if (service.listen(QHostAddress::Any, 8080))
           log->append("Lancement du service");
        else log->append("Problème de connexion");
        bouton->setText("Arrêter service");
    }
    else {
        service.close();
        log->append("Arrêt du service");
        bouton->setText("Démarrer service");
    }
}

void Principal::nouvelleConnexion()
{    
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    log->append(nom+" vient de se connecter");
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;
    listeDesConnectes();
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &message)
{
    QWebSocket *client = (QWebSocket *) sender();
    QString repondre = connectes[client] + " > "+message;
    client->sendTextMessage(repondre);
    log->append(repondre);
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    log->append(nom + " vient de se déconnecter");
    connectes.erase(client);
    envoyerATous(nom + " vient de se déconnecter");
    listeDesConnectes();
}

void Principal::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Principal::listeDesConnectes()
{
    QString liste = "[";
    for (auto &client : connectes) liste.append(" "+client.second);
    liste.append(" ]");
    envoyerATous("Connectés : "+liste);
}

#include "principal.h"
#include <QUrl>
#include <QJsonObject>
#include <QJsonDocument>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("chat", QWebSocketServer::NonSecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
}

void Principal::demarrer(bool etat)
{
    if (etat) {
        if (service.listen(QHostAddress::Any, 8080))
           log->append("Lancement du service");
        else log->append("Problème de connexion");
        bouton->setText("Arrêter service");
    }
    else {
        service.close();
        log->append("Arrêt du service");
        bouton->setText("Démarrer service");
    }
}

void Principal::nouvelleConnexion()
{    
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    log->append(nom+" vient de se connecter");
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;
    listeDesConnectes();
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &texte)
{
    QWebSocket *client = (QWebSocket *) sender();
    QString expediteur = connectes[client];
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    QJsonObject json = document.object();
    QString destinataire = json["cible"].toString();
    QString message = json["message"].toString();
    bool trouve = false;
    for (auto &cible : connectes)
        if (cible.second == destinataire) {
            cible.first->sendTextMessage(expediteur+" > "+message);
            client->sendTextMessage("Message envoyé");
            trouve = true;
        }
    if (!trouve) client->sendTextMessage("Cible inconnue");
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    log->append(nom + " vient de se déconnecter");
    connectes.erase(client);
    envoyerATous(nom + " vient de se déconnecter");
    listeDesConnectes();
}

void Principal::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Principal::listeDesConnectes()
{
    QString liste = "[";
    for (auto &client : connectes) liste.append(" "+client.second);
    liste.append(" ]");
    envoyerATous("Connectés : "+liste);
}

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
#include "ui_principal.h"
using namespace std;

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
    map<QString, QString> messages;
public slots:
    void demarrer(bool etat);
    void nouvelleConnexion();
    void receptionMessage(const QString &texte);
    void deconnexion();
private:
    void envoyerATous(const QString &message);
    void listeDesConnectes();
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QUrl>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("chat", QWebSocketServer::NonSecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
}

void Principal::demarrer(bool etat)
{
    if (etat) {
        if (service.listen(QHostAddress::Any, 8080))
           log->append("Lancement du service");
        else log->append("Problème de connexion");
        bouton->setText("Arrêter service");
    }
    else {
        service.close();
        log->append("Arrêt du service");
        bouton->setText("Démarrer service");
    }
}

void Principal::nouvelleConnexion()
{    
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    log->append(nom+" vient de se connecter");
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;
    listeDesConnectes();
    auto recherche = messages.find(nom);
    if (recherche!=messages.end()) {
        client->sendTextMessage(recherche->second);
        messages.erase(nom);
    }
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &texte)
{
    QWebSocket *client = (QWebSocket *) sender();
    QString expediteur = connectes[client];
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    QJsonObject json = document.object();
    QString destinataire = json["cible"].toString();
    QString message = json["message"].toString();
    bool trouve = false;
    for (auto &cible : connectes)
        if (cible.second == destinataire) {
            cible.first->sendTextMessage(expediteur+" > "+message);
            client->sendTextMessage("Message envoyé");
            trouve = true;
        }
    if (!trouve) {
        client->sendTextMessage("Destinataire non encore connecté");
        messages[destinataire] = expediteur+" > "+message;
    }
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    log->append(nom + " vient de se déconnecter");
    connectes.erase(client);
    envoyerATous(nom + " vient de se déconnecter");
    listeDesConnectes();
    disconnect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    disconnect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Principal::listeDesConnectes()
{
    QString liste = "[";
    for (auto &client : connectes) liste.append(" "+client.second);
    liste.append(" ]");
    envoyerATous("Connectés : "+liste);
}

Destinataire pas encore connecté

Si le destinataire du message n'est pas encore présent, nous conservons son message lors de l'exécution de la méthode receptionMessage().

Nouvelle ouverture de session

A chaque fois qu'un nouveau client se connecte, il faut vérifier si un message personnel n'est pas en attente. Si c'est le cas, le message est alors tout de suite envoyé au client. Il ne faut pas oublier de le supprimer de la liste des messages conservés.

Désactiver les événements des clients qui se déconnectent

Vous remarquez que j'ai rajouté deux lignes supplémentaires dans la méthode deconnexion(). À chaque fois qu'un nouveau client se connecte, nous avons prévu une gestion événementielle adaptée. Il est souhaitable de désactiver cette gestion personnalisée dès que le client se déconnecte et ne fait donc plus parti du service.

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
#include "ui_principal.h"
using namespace std;

struct Photo
{
    QString expediteur;
    QString destinataire;
    QString fichier;
};

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
    map<QString, Photo> photos;
    Photo photo;
    int id = 1;
public slots:
    void demarrer(bool etat);
    void nouvelleConnexion();
    void receptionMessage(const QString &texte);
    void receptionPhoto(const QByteArray &octets);
    void deconnexion();
private:
    void envoyerATous(const QString &message);
    void listeDesConnectes();
};

#endif // PRINCIPAL_H

Nouvelle structure

Un certain nombre de nouveautés apparaissent dans la partie déclaration, notamment une nouvelle structure, nommée Photo qui va nous permettre d'enregistrer, pour une même entité, un certain nombre d'élément. Comme nous nous en doutons, pour envoyer une photo il est important de connaître son expéditeur, son destinataire et également le nom du fichier de sauvegarde si le destinataire n'est pas encode connecté.

Nouvelle map

Vous remarquez également que la map a changée de nom, nous avons maintenant l'attribut photos à la place de messages. La structure de la map n'est plus la même puisque cette fois-ci à chaque destinataire nous enregistrons les informations issues de la structure Photo.

Enregistrement temporaire

Vous savez que l'envoi d'un photo se déroule en deux phases, d'abord le nom du destinataire est envoyé et ensuite le contenu de la photo elle-même. C'est pour cela que nous avons besoin de l'attribut photo.

Identifier le fichier temporaire

Dans le cas où le destinataire n'est pas encore connecté, nous devons enregistrer la photo dans un fichier. Le nom du fichier doit être un identifiant unique, ici un simple numéro qui sera automatiquement incrémenté, représenté par l'attribut id.

Nouvelle méthode

Pour recevoir la photo, nous passons par la méthode receptionPhoto() qui permet de récupérer le flux d'octets.

#include "principal.h"
#include <QUrl>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QFile>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("chat", QWebSocketServer::NonSecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
}

void Principal::demarrer(bool etat)
{
    if (etat) {
        if (service.listen(QHostAddress::Any, 8080))
           log->append("Lancement du service");
        else log->append("Problème de connexion");
        bouton->setText("Arrêter service");
    }
    else {
        service.close();
        log->append("Arrêt du service");
        bouton->setText("Démarrer service");
    }
}

void Principal::nouvelleConnexion()
{    
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    log->append(nom+" vient de se connecter");
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;   
    listeDesConnectes();
    auto recherche = photos.find(nom);
    if (recherche!=photos.end()) {
        client->sendTextMessage("Photo de "+recherche->second.expediteur);
        QFile fichier(recherche->second.fichier);
        fichier.open(QIODevice::ReadOnly);
        QByteArray octets = fichier.readAll();
        client->sendBinaryMessage(octets);
        photos.erase(nom);
        fichier.remove();
    }
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(binaryMessageReceived(QByteArray)), this, SLOT(receptionPhoto(QByteArray)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &texte)
{
    QWebSocket *client = (QWebSocket *) sender();
    photo.expediteur = connectes[client];
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    QJsonObject json = document.object();
    photo.destinataire = json["cible"].toString();
}

void Principal::receptionPhoto(const QByteArray &octets)
{
    QWebSocket *client = (QWebSocket *) sender();
    bool trouve = false;
    for (auto &cible : connectes)
       if (cible.second == photo.destinataire) {
           cible.first->sendTextMessage("Photo de "+photo.expediteur);
           cible.first->sendBinaryMessage(octets);
           client->sendTextMessage("Photo envoyée");
           trouve = true;
       }
    if (!trouve) {
        client->sendTextMessage("Destinataire pas encore connecté");
        photo.fichier = QString("/home/manu/Images/%1").arg(id++);
        photos[photo.destinataire] = photo;
        QFile fichier(photo.fichier);
        fichier.open(QIODevice::WriteOnly);
        fichier.write(octets);
    }
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    log->append(nom + " vient de se déconnecter");
    connectes.erase(client);
    envoyerATous(nom+" vient de se déconnecter");
    listeDesConnectes();
    disconnect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    disconnect(client, SIGNAL(binaryMessageReceived(QByteArray)), this, SLOT(receptionPhoto(QByteArray)));
    disconnect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Principal::listeDesConnectes()
{
    QJsonArray liste;
    for (auto &client : connectes) liste.append(client.second);
    QJsonObject json;
    json["connectés"] = liste;
    QJsonDocument document(json);
    for (auto &client : connectes) client.first->sendTextMessage(document.toJson());
}

Gestion événementielle

Nous devons maintenant prendre en compte un nouveau type de message entrant pour chaque client connecté. Puisque des flux binaires peuvent être transmis par le réseau, il faut pouvoir activer et désactiver par la suite la méthode de rappel receptionPhoto().

Réception de message textuel

La méthode receptionMessage() n'a plus la même fonction. L'objectif maintenant est de récupéré le nom du destinataire et de le sauvegarder temporairement, en même temps d'ailleurs que l'expéditeur. Comme le texte envoyé est format JSON, il est nécessaire de le décripter.

Gestion de la photo reçue

La nouvelle méthode receptionPhoto() permet de récupérer le flux d'octets venant du client. Nous devons contrôler si le destinataire de la photo est connecté. Si c'est le cas, nous envoyons instantanément un message stipulant le nom de l'expéditeur de la photo et tout de suite après, nous envoyons le flux d'octets ainsi récupéré. En même temps, nous envoyons également un message à l'expéditeur confirmant l'envoi de la photo. Si le destinataire n'est pas encore présent sur le réseau, nous devons enregistrer la photo dans un fichier avec un identifiant unique. Nous enregistrons toutes ces informations expéditeur, destinaire et nom du fichier dans la map photos dans l'attente de la connexion du destinataire.

Le destinataire se connecte enfin

Dès qu'un nouveau client se connecte, il faut vérifier s'il ne dispose d'une photo en attente. Si c'est le cas, dans la méthode nouvelleConnexion(), nous parcourons la map photos à la recherche de l'expéditeur. Ce dernier sera alors averti sous forme de texte. Il faut ensuite récupérer les octets du fichier photo sauvegardé temporairement et les envoyés directement au destinataire. Il faut penser enfin à supprimer le fichier photo ainsi que les informations relatives dans la map photos.

Revoir la liste des connectés

Pour conclure, pour être en bonne relation avec le client, vous devez formaliser la liste des connectés au format JSON.

Avantages

L'intégration de données dans l'exécutable présente plusieurs avantages : les données ne peuvent être perdues et cette opération permet la création d'exécutables véritablement autonomes.

Inconvénients

Les inconvénients sont les suivants : si les données intégrées doivent être changées, il est impératif de remplacer l'exécutable entier, et la taille de ce dernier sera plus importante car il doit s'adapter aux données intégrées.

QFile(nom du fichier)

Construit un objet représentant le fichier spécifié en argument. Si vous spécifier un fichier au travers d'un répertoire, vous utilisez le séparateur /  quelque soit le système de fichier, même pour Windows. ATTENTION, le symbole \ n'est pas du tout supporté.

copy(nom du fichier source, nom du fichier destination)

Copie un fichier et en crée un autre. Si l'opération s'est bien déroulée, la fonction retourne true, sinon false dans le cas contraire.

exists()

Permet de savoir si le fichier représenté par QFile existe vraiment.

fileName() - setFileName(nom du fichier)

Permet de connaître le nom du fichier représenté par QFile. Il est également possible de représenter un autre fichier au moyen du même objet QFile.

open(mode d'ouverture)

Ouvre réellement le fichier représenté par QFile. Nous pouvons ouvrir le fichier en lecture seule QIODevice::ReadOnly, en écriture seule QIODevice::WriteOnly, en lecture et écriture QIODevice::ReadWrite. Vous pouvez rajoutez des spécifications supplémentaires pour indiquer par exemple que le fichier doit être un fichier texte au moyen de la constante suivante QIODevice::Text.

permissions() – setPermissions(permissions)

Il est possible de connaître ou de régler les permissions accordées pour chaque fichier. Ces permissions sont de la même nature que celles que vous rencontrez sous les systèmes Unix. La classe QFile possède en interne une énumération dénommée Permission qui propose l'ensemble des constantes correspondant à ce système de fichier. Nous retrouvons les quatre types d'utilisateurs, respectivement : Propriétaire, Utilisateur, Groupe et Autre. enum Permission {ReadOwner, WriteOwner, ExeOwner, ReadUser, WriteUser, ExeUser, ReadGroup, WriteGroup, ExeGroup, ReadOther, WriteOther, ExeOther};

remove()

Supprime définitivement le fichier en cours et renvoie true si l'opération s'est déroulée correctement.

rename(nouveau nom)

Permet de changer le nom du fichier.

close()

Clôture le fichier si ce dernier est ouvert. Permet ainsi d'éviter de perdre des données. Ceci-dit, cette méthode est automatiquement appelée lorsque l'objet QFile est détruit, notamment lorsque nous sortons de la portée de la déclaration de l'objet.

size()

Retourne la taille du fichier en octets.

#include "principal.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Principal w;
//    w.show();

    return a.exec();
}

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
#include <QSystemTrayIcon>
#include "ui_principal.h"
using namespace std;

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
    map<QString, QString> messages;
    bool quitter = false;
    QSystemTrayIcon *notification;
public slots:
    void demarrer(bool valide);
    void nouvelleConnexion();
    void receptionMessage(const QString &texte);
    void deconnexion();
    void arreter();
protected:
    void closeEvent(QCloseEvent *);
private:
    void envoyerATous(const QString &message);
    void listeDesConnectes();  
    void setNotification();
};

#endif // PRINCIPAL_H

Arrêt du programme

La clôture du programme ne peut se faire qu'avec le menu contextuel Quitter l'application et non pas avec le bouton système de clôture x . Dès que nous cliquons sur cette option de menu, la méthode arreter est alors automatiquement lancée. Cette méthode active l'attribut booléen quitter false par défaut qui sert maintenant à déterminer si nous désirons réellement quitter l'application. Nous devons également redéfinir la méthode closeEvent() afin d'empêcher la clôture automatique avec le bouton système x .

Système de notification

Pour mettre en oeuvre le système de notification, vous devez utiliser la classe QSystemIconTray. L'initialisation de l'attribut notification et de la mise en place du menu contextuel sont décrits dans la méthode setNotification().

#include "principal.h"
#include <QUrl>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QMenu>
#include <QCloseEvent>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("chat", QWebSocketServer::NonSecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
    setNotification();
}

void Principal::demarrer(bool valide)
{
    if (valide) {
        if (service.listen(QHostAddress::Any, port->value()))
        {
           etat->showMessage("Lancement du service");
           notification->showMessage("Action", "Lancement du service", QSystemTrayIcon::Information);
        }
        else etat->showMessage("Problème de connexion");
        actionService->setText("Arrêter le service");
        port->setReadOnly(true);
    }
    else {
        service.close();
        etat->showMessage("Arrêt du service");
        notification->showMessage("Action", "Arrêt du service", QSystemTrayIcon::Information);
        actionService->setText("Démarrer le service");
        port->setReadOnly(false);
    }
}

void Principal::nouvelleConnexion()
{
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    etat->showMessage(nom+" vient de se connecter");
    notification->showMessage("Evénement", nom+" vient de se connecter", QSystemTrayIcon::Information);
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;
    listeDesConnectes();
    auto recherche = messages.find(nom);
    if (recherche!=messages.end()) {
        client->sendTextMessage(recherche->second);
        messages.erase(nom);
    }
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &texte)
{
    QWebSocket *client = (QWebSocket *) sender();
    QString expediteur = connectes[client];
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    QJsonObject json = document.object();
    QString destinataire = json["cible"].toString();
    QString message = json["message"].toString();
    bool trouve = false;
    for (auto &cible : connectes)
        if (cible.second == destinataire) {
            cible.first->sendTextMessage(expediteur+" > "+message);
            client->sendTextMessage("Message envoyé");
            trouve = true;
        }
    if (!trouve) {
        client->sendTextMessage("Destinataire non encore connecté");
        messages[destinataire] = expediteur+" > "+message;
    }
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    etat->showMessage(nom + " vient de se déconnecter");
    notification->showMessage("Evénement", nom+" vient de se déconnecter", QSystemTrayIcon::Information);
    connectes.erase(client);
    envoyerATous(nom + " vient de se déconnecter");
    listeDesConnectes();
    disconnect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    disconnect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Principal::listeDesConnectes()
{
    QJsonArray liste;
    for (auto &client : connectes) liste.append(client.second);
    QJsonObject json;
    json["connectés"] = liste;
    QJsonDocument document(json);
    for (auto &client : connectes) client.first->sendTextMessage(document.toJson());
}

void Principal::setNotification()
{
    QMenu *menu = new QMenu(this);
    menu->addAction(actionService);
    menu->addAction(actionAfficher);
    menu->addSeparator();
    menu->addAction(actionQuitter);
    notification = new QSystemTrayIcon(QIcon(":/icones/ressources/chat.png"), this);
    notification->setContextMenu(menu);
    notification->show();
    notification->showMessage("Bonjour", "Service chat", QSystemTrayIcon::Information);
}

void Principal::closeEvent(QCloseEvent *evt)
{
    if (!quitter) {
        hide();
        evt->ignore();
    }
}

void Principal::arreter()
{
    quitter = true;
    close();
}

Clôture du programme

Dans la méthode closeEvent() nous vérifions bien que l'utilisateur désire quitter le programme. Si c'est le cas, nous ne faisons rien de particulier, ce qui donnera l'arrêt normal et définitf. Dans le cas contraire, nous demandons à cacher la fenêtre et d'ignorer la demande de clôture. La méthode arreter() valide la demande de clôture.

Système de notification

Dans votre application, si vous désirez mettre en œuvre une notification, vous devez donc créer un objet relatif à la classe QSystemIconTray. Durant la phase de création, vous devez indiquer quel est l'élément qui lance cette notification, généralement vous spécifiez le pointeur this. Vous pouvez également proposer à ce moment là, l'icône de notification. Vous devez ensuite proposer le menu contextuel qui est à construire au préalable au moyen de la méthode setContextMenu(). Il faut bien entendu rendre visible votre notification à l'aide de la méthode show(). Enfin, suivant des événements particuliers, vous pouvez visualiser des messages contextuels au moyen de la méthode showMessage().

La méthode showMessage(titre, message, icône, durée)

Message contextuel avec un titre qui apparaît pendant 10 secondes par défaut. Si vous désirez changer le temps d'affichage, vous devez spécifier le nombre de millisecondes sur l'argument durée. Dans ce message contextuel apparaît une petite icône qui indique le type de message, soit une simple information, soit un message d'avertissement ou enfin un message d'erreur. Prenez l'une des constantes suivantes pour choisir l'icône qui convient :

enum {NoIcon, Information, Warning, Critical};

{
    "adresse": "192.168.1.75",
    "automatique": true,
    "login": "bruno",
    "port": "8080"
}

#include "principal.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Principal w;
//    w.show();

    return a.exec();
}

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QtWebSockets/QWebSocket>
#include <QSystemTrayIcon>
#include "ui_principal.h"

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocket webSocket;
    bool estConnecte = false, quitter = false;
    QSystemTrayIcon *notification;
private slots:
    void commuter();
    void envoiMessage();
    void receptionMessage(const QString &texte);
    void connexion();
    void deconnexion();
    void enregistrerConfig();
    void arreter();
protected:
    void closeEvent(QCloseEvent *);
private:
    void seConnecter();
    void lireConfig();
    void setNotification();
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QFile>
#include <QMenu>
#include <QCloseEvent>

Principal::Principal(QWidget *parent) :  QMainWindow(parent)
{
    setupUi(this);
    setNotification();
    lireConfig();
    connect(&webSocket, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(&webSocket, SIGNAL(connected()), this, SLOT(connexion()));
    connect(&webSocket, SIGNAL(disconnected()), this, SLOT(deconnexion()));
    connect(&webSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(deconnexion()));
}

void Principal::commuter()
{
    estConnecte = !estConnecte;
    if (estConnecte && !login->text().isEmpty()) seConnecter();
    else webSocket.close();
}

void Principal::seConnecter()
{
    QString url = "ws://";
    url+=adresse->text()+":";
    url+=port->text()+"/";
    url+=login->text();
    webSocket.open(QUrl(url));
    onglets->setCurrentIndex(1);
}

void Principal::envoiMessage()
{
    if (destinataire->text().isEmpty()) reception->append("ATTENTION, il faut un destinataire");
    else {
      QJsonObject json;
      json["cible"] = destinataire->text();
      json["message"] = message->text();
      QJsonDocument document(json);
      webSocket.sendTextMessage(document.toJson());
    }
}

void Principal::receptionMessage(const QString &texte)
{
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    if (!document.isObject()) {
        reception->append(texte);
        notification->showMessage("Notification", texte, QSystemTrayIcon::Information);
    }
    else {
       QJsonObject json = document.object();
       if (json.contains("expéditeur"))
       {
          QString expediteur = json["expéditeur"].toString();
          QString message = json["message"].toString();
          reception->append(expediteur+" > "+message);
          notification->showMessage("Nouveau message", expediteur+" > "+message, QSystemTrayIcon::Information);
       }
       if (json.contains("connectés"))
       {
          QJsonArray connectes = json["connectés"].toArray();
          logins->clear();
          for (int i=0; i<connectes.count(); i++)
             if (connectes[i].toString() != login->text())
                 logins->addItem(connectes[i].toString());
       }
    }
}

void Principal::connexion()
{
    reception->append("Connecté au service");
}

void Principal::deconnexion()
{
    reception->append("Déconnecté du service");
    logins->clear();
}

void Principal::lireConfig()
{
    QFile fichier("ressources/config");
    if (fichier.open(QIODevice::ReadOnly))
    {
        QTextStream lire(&fichier);
        QJsonDocument document = QJsonDocument::fromJson(lire.readAll().toUtf8());
        QJsonObject json = document.object();
        adresse->setText(json["adresse"].toString());
        port->setText(json["port"].toString());
        login->setText(json["login"].toString());
        bool lancer = json["automatique"].toBool();
        automatique->setChecked(lancer);
        if (lancer) boutonConnexion->click();
    }
}

void Principal::enregistrerConfig()
{

    QFile fichier("ressources/config");
    if (fichier.open(QIODevice::WriteOnly))
    {
        QTextStream ecrire(&fichier);
        QJsonObject json;
        json["adresse"] = adresse->text();
        json["port"] = port->text();
        json["login"] = login->text();
        json["automatique"] = automatique->isChecked();
        QJsonDocument document(json);
        ecrire << document.toJson();
    }
}

void Principal::setNotification()
{
    QMenu *menu = new QMenu(this);
    menu->addAction(actionConnecter);
    menu->addAction(actionAfficher);
    menu->addSeparator();
    menu->addAction(actionQuitter);
    notification = new QSystemTrayIcon(QIcon(":/icones/ressources/chat_contacts.png"), this);
    notification->setContextMenu(menu);
    notification->show();
    notification->showMessage("Bonjour", "Application chat", QSystemTrayIcon::Information);
}

void Principal::closeEvent(QCloseEvent *evt)
{
    if (!quitter) {
        hide();
        evt->ignore();
    }
}

void Principal::arreter()
{
    quitter = true;
    close();
}

QT      += core websockets
QT      -= gui
CONFIG  += c++11 console
TARGET   = ServeurWS
TEMPLATE = app

SOURCES += principal.cpp service.cpp
HEADERS += service.h

#include <QtCore/QCoreApplication>
#include "service.h"

int main(int nombre, char *options[])
{
    if (nombre==2)
    {
        QCoreApplication appli(nombre, options);
        Service websocket(options[1]);
        QObject::connect(&websocket, SIGNAL(arreter()), &appli, SLOT(quit()));
        return appli.exec();
    }
    else return 0;
}

Fonction principale

Ce code source possède la fonction principale de l'application. Comme pour tout environnement Qt, nous passons par la classe QCoreApplication.

Intérêt de la classe QCoreApplication

Cette classe possède un certain nombre de fonctionnalités importantes pour la gestion d'une application. La première concerne la gestion événementielle grâce à la méthode connect(). La deuxième qui va avec et qui est fondamentale est de permettre le fonctionnement continuel, grâce à la méthode exec() qui tourne en tâche de fond et qui attend jusqu'à ce que l'utilisateur désire s'arrêter.

Lancement du service et arrêt du programme

Le service est représenté par la classe du même nom Service. Nous créons un objet de cette classe avec en argument du constructeur le numéro du service désiré, proposé en option de la ligne de commande. L'arrêt de l'application et donc du service se fait lorsque le signal arreter() de la classe Service est sollicité. La méthode quit() de la classe QCoreApplication est alors exécutée se qui clôture définitivement l'application, la méthode exec() se termine.

#ifndef SERVICE_H
#define SERVICE_H

#include <QObject>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
using namespace std;

class Service : public QObject
{
    Q_OBJECT
public:
    explicit Service(QString port, QObject *parent = 0);
signals:
    void arreter();
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
    map<QString, QString> messages;
public slots:
    void nouvelleConnexion();
    void receptionMessage(const QString &texte);
    void deconnexion();
private:
    void envoyerATous(const QString &message);
    void listeDesConnectes();
};

#endif // SERVICE_H

#include "service.h"

#include <QUrl>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>

Service::Service(QString port, QObject *parent) : QObject(parent), service("chat", QWebSocketServer::NonSecureMode, this)
{   
    if (service.listen(QHostAddress::Any, port.toInt()))
      connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
    else arreter();
}

void Service::nouvelleConnexion()
{
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;
    listeDesConnectes();
    auto recherche = messages.find(nom);
    if (recherche!=messages.end()) {
        client->sendTextMessage(recherche->second);
        messages.erase(nom);
    }
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Service::receptionMessage(const QString &texte)
{
    if (texte=="stop") { arreter(); return; }
    QWebSocket *client = (QWebSocket *) sender();
    QString expediteur = connectes[client];
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    QJsonObject json = document.object();
    QString destinataire = json["cible"].toString();
    QString message = json["message"].toString();
    bool trouve = false;
    for (auto &cible : connectes)
        if (cible.second == destinataire) {
            cible.first->sendTextMessage(expediteur+" > "+message);
            client->sendTextMessage("Message envoyé");
            trouve = true;
        }
    if (!trouve) {
        client->sendTextMessage("Destinataire non encore connecté");
        messages[destinataire] = expediteur+" > "+message;
    }
}

void Service::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    connectes.erase(client);
    envoyerATous(nom + " vient de se déconnecter");
    listeDesConnectes();
    disconnect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    disconnect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Service::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Service::listeDesConnectes()
{
    QString liste = "[";
    for (auto &client : connectes) liste.append(" "+client.second);
    liste.append(" ]");
    envoyerATous("Connectés : "+liste);
}

QT       += core gui websockets
CONFIG   += c++11

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET   = WebSocketServeur
TEMPLATE = app

SOURCES  += main.cpp  principal.cpp
HEADERS  += principal.h
FORMS    += principal.ui

RESOURCES += ressources.qrc

#include "principal.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Principal w;
//    w.show();

    return a.exec();
}

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QWebSocketServer>
#include <QWebSocket>
#include <map>
#include <QSystemTrayIcon>
#include "ui_principal.h"
using namespace std;

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocketServer service;
    map<QWebSocket *, QString> connectes;
    map<QString, QString> messages;
    bool quitter = false;
    QSystemTrayIcon *notification;
public slots:
    void demarrer(bool valide);
    void nouvelleConnexion();
    void receptionMessage(const QString &texte);
    void deconnexion();
    void arreter();
protected:
    void closeEvent(QCloseEvent *);
private:
    void envoyerATous(const QString &message);
    void listeDesConnectes();  
    void setNotification();
    void configurationSSL();
};

#endif // PRINCIPAL_H

Modification du code précédent

La seule méthode rajouté se nomme configurationSSL(). Cette méthode sera automatiquement appelée par le constructeur et c'est à ce moment là que les clés que nous avons générées seront prisent en compte. Toute la gestion de la sécurisation par SSL se trouve dans cette unique méthode.

#include "principal.h"
#include <QUrl>
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QMenu>
#include <QCloseEvent>
#include <QSslKey>

Principal::Principal(QWidget *parent) : QMainWindow(parent), service("chat", QWebSocketServer::SecureMode, this)
{
    setupUi(this);
    connect(&service, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));
    setNotification();
    configurationSSL();
}

void Principal::configurationSSL()
{
  QFile cert(":/ssl/ressources/serveur.crt");
  QFile cle(":/ssl/ressources/serveur.key");
  cert.open(QIODevice::ReadOnly);
  cle.open(QIODevice::ReadOnly);
  QSslCertificate certificat(&cert);
  QSslKey cleSSL(&cle, QSsl::Rsa);

  QSslConfiguration ssl;
  ssl.setPeerVerifyMode(QSslSocket::VerifyNone);
  ssl.setLocalCertificate(certificat);
  ssl.setPrivateKey(cleSSL);
  service.setSslConfiguration(ssl);
}

void Principal::demarrer(bool valide)
{
    if (valide) {
        if (service.listen(QHostAddress::Any, port->value()))
        {
           etat->showMessage("Lancement du service");
           notification->showMessage("Action", "Lancement du service", QSystemTrayIcon::Information);
        }
        else etat->showMessage("Problème de connexion");
        actionService->setText("Arrêter le service");
        port->setReadOnly(true);
    }
    else {
        service.close();
        etat->showMessage("Arrêt du service");
        notification->showMessage("Action", "Arrêt du service", QSystemTrayIcon::Information);
        actionService->setText("Démarrer le service");
        port->setReadOnly(false);
    }
}

void Principal::nouvelleConnexion()
{
    QWebSocket *client = service.nextPendingConnection();
    QString nom = client->requestUrl().path();
    nom.remove('/');
    client->sendTextMessage("Bonjour "+nom);
    etat->showMessage(nom+" vient de se connecter");
    notification->showMessage("Evénement", nom+" vient de se connecter", QSystemTrayIcon::Information);
    envoyerATous(nom+" vient de se connecter");
    connectes[client] = nom;
    listeDesConnectes();
    auto recherche = messages.find(nom);
    if (recherche!=messages.end()) {
        client->sendTextMessage(recherche->second);
        messages.erase(nom);
    }
    connect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::receptionMessage(const QString &texte)
{
    QWebSocket *client = (QWebSocket *) sender();
    QString expediteur = connectes[client];
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    QJsonObject json = document.object();
    QString destinataire = json["cible"].toString();
    QString message = json["message"].toString();
    bool trouve = false;
    for (auto &cible : connectes)
        if (cible.second == destinataire) {
            cible.first->sendTextMessage(expediteur+" > "+message);
            client->sendTextMessage("Message envoyé");
            trouve = true;
        }
    if (!trouve) {
        client->sendTextMessage("Destinataire non encore connecté");
        messages[destinataire] = expediteur+" > "+message;
    }
}

void Principal::deconnexion()
{
    QWebSocket *client = (QWebSocket *) sender();
    client->deleteLater();
    QString nom = connectes[client];
    etat->showMessage(nom + " vient de se déconnecter");
    notification->showMessage("Evénement", nom+" vient de se déconnecter", QSystemTrayIcon::Information);
    connectes.erase(client);
    envoyerATous(nom + " vient de se déconnecter");
    listeDesConnectes();
    disconnect(client, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    disconnect(client, SIGNAL(disconnected()), this, SLOT(deconnexion()));
}

void Principal::envoyerATous(const QString &message)
{
   for (auto &client : connectes) client.first->sendTextMessage(message);
}

void Principal::listeDesConnectes()
{
    QJsonArray liste;
    for (auto &client : connectes) liste.append(client.second);
    QJsonObject json;
    json["connectés"] = liste;
    QJsonDocument document(json);
    for (auto &client : connectes) client.first->sendTextMessage(document.toJson());
}

void Principal::setNotification()
{
    QMenu *menu = new QMenu(this);
    menu->addAction(actionService);
    menu->addAction(actionAfficher);
    menu->addSeparator();
    menu->addAction(actionQuitter);
    notification = new QSystemTrayIcon(QIcon(":/icones/ressources/chat.png"), this);
    notification->setContextMenu(menu);
    notification->show();
    notification->showMessage("Bonjour", "Service chat", QSystemTrayIcon::Information);
}

void Principal::closeEvent(QCloseEvent *evt)
{
    if (!quitter) {
        hide();
        evt->ignore();
    }
}

void Principal::arreter()
{
    quitter = true;
    close();
}

QWebSocketServer::SecureMode

Demande de sécurisation des transactions. Cette classe permet d'utiliser le protocole suivant deux modes, avec ou sans sécurité. Dans ce dernier cas, l'URL de connexion est la suivante wss://adresse:port/action à la place de ws://adresse:port/action.

QSslConfiguration

Heureusement, il existe une classe spécialisée pour la configuration du protocole de sécurité SSL avec la prise en compte des différentes clés que nous venons de générer.

QSslCertificate

Comme son nom l'indique, cette classe représente la clé publique certifiée à partir du fichier serveur.crt que nous venons de produire.

QSslKey

Comme son nom l'indique, cette classe représente la clé privée à partir du fichier serveur.key que nous venons de produire. Vous devez préciser le type d'algorithme de cryptage. Nous avons vu que pour générer cette clé privée, openssl utilise le cryptage RSA 2048 bits.

ssl.setPeerVerifyMode(QSslSocket::VerifyNone);

Lorsque vous utilisez un navigateur et que vous allez sur un site en mode HTTPS, il est généralement souhaitable de connaître l'identité de l'organisme qui a signé le certificat. Pour les applications classiques fenêtrées cette vérification ne possède peu d'intérêt puisque la communication en mode SSL se fait en coulisse sans que l'utilisateur s'en rende compte.

{
    "adresse": "192.168.1.75",
    "automatique": true,
    "login": "bruno",
    "port": "8080"
}

#include "principal.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Principal w;
//    w.show();

    return a.exec();
}

#ifndef PRINCIPAL_H
#define PRINCIPAL_H

#include <QMainWindow>
#include <QtWebSockets/QWebSocket>
#include <QSystemTrayIcon>
#include "ui_principal.h"

class Principal : public QMainWindow, public Ui::Principal
{
    Q_OBJECT

public:
    explicit Principal(QWidget *parent = 0);
private:
    QWebSocket webSocket;
    bool estConnecte = false, quitter = false;
    QSystemTrayIcon *notification;
private slots:
    void commuter();
    void envoiMessage();
    void receptionMessage(const QString &texte);
    void connexion();
    void deconnexion();
    void enregistrerConfig();
    void arreter();
protected:
    void closeEvent(QCloseEvent *);
private:
    void seConnecter();
    void lireConfig();
    void setNotification();
    void configurationSSL();
};

#endif // PRINCIPAL_H

#include "principal.h"
#include <QJsonObject>
#include <QJsonArray>
#include <QJsonDocument>
#include <QFile>
#include <QMenu>
#include <QCloseEvent>
#include <QSslKey>

Principal::Principal(QWidget *parent) :  QMainWindow(parent)
{
    setupUi(this);
    setNotification();
    lireConfig();
    configurationSSL();
    connect(&webSocket, SIGNAL(textMessageReceived(QString)), this, SLOT(receptionMessage(QString)));
    connect(&webSocket, SIGNAL(connected()), this, SLOT(connexion()));
    connect(&webSocket, SIGNAL(disconnected()), this, SLOT(deconnexion()));
    connect(&webSocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(deconnexion()));
}

void Principal::configurationSSL()
{
  QFile cert(":/ssl/ressources/client.crt");
  QFile cle(":/ssl/ressources/client.key");
  cert.open(QIODevice::ReadOnly);
  cle.open(QIODevice::ReadOnly);
  QSslCertificate certificat(&cert);
  QSslKey cleSSL(&cle, QSsl::Rsa);

  QSslConfiguration ssl;
  ssl.setPeerVerifyMode(QSslSocket::VerifyNone);
  ssl.setLocalCertificate(certificat);
  ssl.setPrivateKey(cleSSL);
  webSocket.setSslConfiguration(ssl);
}

void Principal::commuter()
{
    estConnecte = !estConnecte;
    if (estConnecte && !login->text().isEmpty()) seConnecter();
    else webSocket.close();
}

void Principal::seConnecter()
{
    QString url = "wss://";
    url+=adresse->text()+":";
    url+=port->text()+"/";
    url+=login->text();
    webSocket.open(QUrl(url));
    onglets->setCurrentIndex(1);
}

void Principal::envoiMessage()
{
    if (destinataire->text().isEmpty()) reception->append("ATTENTION, il faut un destinataire");
    else {
      QJsonObject json;
      json["cible"] = destinataire->text();
      json["message"] = message->text();
      QJsonDocument document(json);
      webSocket.sendTextMessage(document.toJson());
    }
}

void Principal::receptionMessage(const QString &texte)
{
    QJsonDocument document = QJsonDocument::fromJson(texte.toUtf8());
    if (!document.isObject()) {
        reception->append(texte);
        notification->showMessage("Notification", texte, QSystemTrayIcon::Information);
    }
    else {
       QJsonObject json = document.object();
       if (json.contains("expéditeur"))
       {
          QString expediteur = json["expéditeur"].toString();
          QString message = json["message"].toString();
          reception->append(expediteur+" > "+message);
          notification->showMessage("Nouveau message", expediteur+" > "+message, QSystemTrayIcon::Information);
       }
       if (json.contains("connectés"))
       {
          QJsonArray connectes = json["connectés"].toArray();
          logins->clear();
          for (int i=0; i<connectes.count(); i++)
             if (connectes[i].toString() != login->text())
                 logins->addItem(connectes[i].toString());
       }
    }
}

void Principal::connexion()
{
    reception->append("Connecté au service");
}

void Principal::deconnexion()
{
    reception->append("Déconnecté du service");
    logins->clear();
}

void Principal::lireConfig()
{
    QFile fichier("ressources/config");
    if (fichier.open(QIODevice::ReadOnly))
    {
        QTextStream lire(&fichier);
        QJsonDocument document = QJsonDocument::fromJson(lire.readAll().toUtf8());
        QJsonObject json = document.object();
        adresse->setText(json["adresse"].toString());
        port->setText(json["port"].toString());
        login->setText(json["login"].toString());
        bool lancer = json["automatique"].toBool();
        automatique->setChecked(lancer);
        if (lancer) boutonConnexion->click();
    }
}

void Principal::enregistrerConfig()
{

    QFile fichier("ressources/config");
    if (fichier.open(QIODevice::WriteOnly))
    {
        QTextStream ecrire(&fichier);
        QJsonObject json;
        json["adresse"] = adresse->text();
        json["port"] = port->text();
        json["login"] = login->text();
        json["automatique"] = automatique->isChecked();
        QJsonDocument document(json);
        ecrire << document.toJson();
    }
}

void Principal::setNotification()
{
    QMenu *menu = new QMenu(this);
    menu->addAction(actionConnecter);
    menu->addAction(actionAfficher);
    menu->addSeparator();
    menu->addAction(actionQuitter);
    notification = new QSystemTrayIcon(QIcon(":/icones/ressources/chat_contacts.png"), this);
    notification->setContextMenu(menu);
    notification->show();
    notification->showMessage("Bonjour", "Application chat", QSystemTrayIcon::Information);
}

void Principal::closeEvent(QCloseEvent *evt)
{
    if (!quitter) {
        hide();
        evt->ignore();
    }
}

void Principal::arreter()
{
    quitter = true;
    close();
}

configurationSSL();

Nous avons besoin de la même méthode. Tout le contenu est strictement similaire au serveur. Seul les noms des fichiers relatifs aux clés sont différents.

QString url = "wss://";

ATTENTION : il est impératif d'établir la connexion en mode sécurisé en proposant la bonne URL.