feat: reformat for better understanding and added a client handler list to main server

app/src/main/java/clientserver/client/Client.java

@@ -35,29 +35,26 @@ public class Client {
             int serverPort = 6666;
 
             // 2 - Envoyer un message au serveur
-            String message = "Connection request";
-            byte[] sendData = message.getBytes();
+            String pseudo = "PseudoTest";
+            byte[] sendData = pseudo.getBytes();
             DatagramPacket sendPacket = new DatagramPacket(
-                sendData,
-                sendData.length,
-                serverAddress,
-                serverPort
-            );
+                    sendData,
+                    sendData.length,
+                    serverAddress,
+                    serverPort);
             socketClient.send(sendPacket);
             System.out.println("New connection request sent");
 
             // 3 - Recevoir
             byte[] receivedData = new byte[1024]; // tampon de réception
             DatagramPacket receivedPacket = new DatagramPacket(
-                receivedData,
-                receivedData.length
-            );
+                    receivedData,
+                    receivedData.length);
             socketClient.receive(receivedPacket);
             String reponse = new String(
-                receivedPacket.getData(),
-                0,
-                receivedPacket.getLength()
-            );
+                    receivedPacket.getData(),
+                    0,
+                    receivedPacket.getLength());
 
             if (reponse.startsWith("PORT:")) {
                 int newPort = Integer.parseInt(reponse.substring(5));
@@ -69,13 +66,34 @@ public class Client {
                     String messagePort = "Test";
                     byte[] envoyeesPort = messagePort.getBytes();
                     DatagramPacket paquetPort = new DatagramPacket(
-                        envoyeesPort,
-                        envoyeesPort.length,
-                        serverAddress,
-                        newPort
-                    );
+                            envoyeesPort,
+                            envoyeesPort.length,
+                            serverAddress,
+                            newPort);
                     socketClient.send(paquetPort);
                     System.out.println("Test sent");
+
+                    try {
+                        // Définir un timeout court pour que la boucle continue
+                        socketClient.setSoTimeout(1000);
+
+                        byte[] reponseData = new byte[1024];
+                        DatagramPacket reponsePacket = new DatagramPacket(
+                                reponseData,
+                                reponseData.length);
+                        socketClient.receive(reponsePacket);
+
+                        String messageServeur = new String(
+                                reponsePacket.getData(),
+                                0,
+                                reponsePacket.getLength());
+
+                        System.out.println("Serveur répond: \n" + messageServeur);
+                    } catch (java.net.SocketTimeoutException e) {
+                        // Ignorer le timeout et continuer
+                        System.out.println("Pas de réponse du serveur cette fois-ci");
+                    }
+
                     TimeUnit.SECONDS.sleep(1);
                 }
             }

app/src/main/java/clientserver/server/ClientHandler.java

@@ -6,69 +6,72 @@ import java.net.DatagramSocket;
 
 public class ClientHandler implements Runnable {
 
-    private final DatagramSocket socket;
+    private final DatagramSocket clientHandlerSocket;
     private final Client client;
     private boolean running = true;
 
     public ClientHandler(DatagramSocket socket, Client client) {
-        this.socket = socket;
+        this.clientHandlerSocket = socket;
         this.client = client;
     }
 
+    public void sendConnectedClients() {
+        Server.sendMessage(clientHandlerSocket, Server.getPseudos(), client.getAddress(), client.getPort());
+    }
+
     public void stop() {
         running = false;
-        if (socket != null && !socket.isClosed()) {
-            socket.close();
+        if (clientHandlerSocket != null && !clientHandlerSocket.isClosed()) {
+            clientHandlerSocket.close();
         }
     }
 
     @Override
     public void run() {
         System.out.println(
-            "Started handler for client " +
-            client.getAddress() +
-            ":" +
-            client.getPort()
-        );
+                "Started handler for client " +
+                        client.getAddress() +
+                        ":" +
+                        client.getPort());
 
         // try {
-        //     socket.setSoTimeout(30000);
+        // socket.setSoTimeout(30000);
         // } catch (Exception e) {
-        //     System.err.println("Could not set socket timeout");
+        // System.err.println("Could not set socket timeout");
         // }
 
-        while (running && !socket.isClosed()) {
-            DatagramPacket packet = Server.receivedPacket(socket);
-            if (packet == null) continue;
+        while (running && !clientHandlerSocket.isClosed()) {
+            DatagramPacket packet = Server.receivedPacket(clientHandlerSocket);
+            if (packet == null)
+                continue;
 
             String message = new String(
-                packet.getData(),
-                0,
-                packet.getLength()
-            );
+                    packet.getData(),
+                    0,
+                    packet.getLength());
             System.out.println(
-                "Received from " +
-                client.getAddress() +
-                ":" +
-                client.getPort() +
-                ": " +
-                message
-            );
+                    "Received from " +
+                            client.getAddress() +
+                            ":" +
+                            client.getPort() +
+                            ": " +
+                            message);
+
+            sendConnectedClients();
             // Reply with echo
             // String response = "ECHO: " + message;
             // Server.sendMessage(
-            //     socket,
-            //     response,
-            //     client.getAddress(),
-            //     client.getPort()
+            // socket,
+            // response,
+            // client.getAddress(),
+            // client.getPort()
             // );
         }
 
         System.out.println(
-            "Client handler terminated for " +
-            client.getAddress() +
-            ":" +
-            client.getPort()
-        );
+                "Client handler terminated for " +
+                        client.getAddress() +
+                        ":" +
+                        client.getPort());
     }
 }

app/src/main/java/clientserver/server/Server.java

@@ -4,12 +4,16 @@ import clientserver.client.Client;
 import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class Server {
 
     private int mainServerPort;
     private DatagramSocket mainServerSocket;
     private boolean isRunning;
+    private static Map<String, ClientHandler> mapPseudosConnectedClientsHandlers = new ConcurrentHashMap<>();
 
     public Server(int port) {
         this.mainServerPort = port;
@@ -40,9 +44,8 @@ public class Server {
     public static DatagramPacket receivedPacket(DatagramSocket socket) {
         byte[] receivedData = new byte[1024];
         DatagramPacket receivedPacket = new DatagramPacket(
-            receivedData,
-            receivedData.length
-        );
+                receivedData,
+                receivedData.length);
 
         try {
             socket.receive(receivedPacket); // Blocking call
@@ -54,73 +57,75 @@ public class Server {
     }
 
     public static void sendMessage(
-        DatagramSocket socket,
-        String message,
-        java.net.InetAddress address,
-        int port
-    ) {
+            DatagramSocket socket,
+            String message,
+            java.net.InetAddress address,
+            int port) {
         try {
             byte[] sendData = message.getBytes();
             DatagramPacket packetToSend = new DatagramPacket(
-                sendData,
-                sendData.length,
-                address,
-                port
-            );
+                    sendData,
+                    sendData.length,
+                    address,
+                    port);
             socket.send(packetToSend);
         } catch (IOException e) {
             System.err.println(
-                "Failed to send message to " + address + ":" + port
-            );
+                    "Failed to send message to " + address + ":" + port);
             e.printStackTrace();
         }
     }
 
     private void handleNewConnection() {
         DatagramPacket packet = receivedPacket(mainServerSocket);
-        if (packet == null) return;
+        if (packet == null)
+            return;
 
-        Client client = new Client(packet.getAddress(), packet.getPort());
+        int originalClientPort = packet.getPort();
+        InetAddress clientAddress = packet.getAddress();
+        ;
 
         // Log the initial connection request
         System.out.println(
-            "New connection request from " +
-            client.getAddress() +
-            ":" +
-            client.getPort()
-        );
+                "New connection request from " +
+                        clientAddress +
+                        ":" +
+                        originalClientPort);
 
         // Process the received message
-        String message = new String(packet.getData(), 0, packet.getLength());
+        String pseudoMessage = new String(packet.getData(), 0, packet.getLength());
         System.out.println(
-            "Received message from " +
-            client.getAddress() +
-            ":" +
-            client.getPort() +
-            ": " +
-            message
-        );
+                "Received message from " +
+                        clientAddress +
+                        ":" +
+                        originalClientPort +
+                        ": " +
+                        pseudoMessage);
 
         // Create a new socket for this client
-        DatagramSocket clientSocket = createNewSocket();
-        if (clientSocket == null) return;
+        DatagramSocket clientHandlerSocket = createNewSocket();
+        if (clientHandlerSocket == null)
+            return;
 
-        int newPort = clientSocket.getLocalPort();
-        client.setPort(newPort);
+        int clientHandlerLocalPort = clientHandlerSocket.getLocalPort();
+
+        Client client = new Client(clientAddress, originalClientPort);
 
         // Send new port information to client
-        String response = "PORT:" + newPort;
+        String response = "PORT:" + clientHandlerLocalPort;
         sendMessage(
-            mainServerSocket,
-            response,
-            client.getAddress(),
-            packet.getPort()
-        );
+                mainServerSocket,
+                response,
+                clientAddress,
+                packet.getPort());
 
         // Create and start a ClientHandler for this connection
-        ClientHandler handler = new ClientHandler(clientSocket, client);
+        ClientHandler handler = new ClientHandler(clientHandlerSocket, client);
         Thread thread = new Thread(handler);
         thread.start();
+
+        // Add client handler to mapPseudosConnectedClients
+        mapPseudosConnectedClientsHandlers.putIfAbsent(pseudoMessage, handler);
     }
 
     public void run() {
@@ -130,11 +135,24 @@ public class Server {
                 handleNewConnection();
             } catch (Exception e) {
                 System.err.println(
-                    "Error handling connection: " + e.getMessage()
-                );
+                        "Error handling connection: " + e.getMessage());
                 e.printStackTrace();
             }
         }
         System.out.println("Server shutdown");
     }
+
+    public static String getPseudos() {
+        StringBuilder pseudos = new StringBuilder("All connected clients:\n");
+        mapPseudosConnectedClientsHandlers.forEach((k, v) -> pseudos.append("Pseudo: ").append(k).append("\n"));
+        return pseudos.toString();
+    }
+
+    public void addConnectedClientHandler(String pseudo, ClientHandler clientHandler) {
+        mapPseudosConnectedClientsHandlers.putIfAbsent(pseudo, clientHandler);
+    }
+
+    public void removeClientHandler(String pseudo) {
+        mapPseudosConnectedClientsHandlers.remove(pseudo);
+    }
 }