From 93e418dbee399974f3032db69cf780e2dd0ea69e Mon Sep 17 00:00:00 2001 From: Alexandre Gonzalvez Date: Wed, 9 Dec 2020 12:18:50 +0100 Subject: [PATCH] Passage en MVC --- .../Clavardage/src/controller/Controller.java | 448 ++++++++++++++++++ .../src/controller/ListeningThread.java | 17 + .../controller/ListeningThreadTCPChat.java | 90 ++++ .../ListeningThreadTCPConnection.java | 91 ++++ .../src/controller/ListeningThreadUDP.java | 121 +++++ Application/Clavardage/src/model/Chat.java | 50 ++ .../Clavardage/src/model/LocalUser.java | 95 ++++ Application/Clavardage/src/model/Message.java | 46 ++ .../Clavardage/src/model/Msg_Text.java | 22 + .../Clavardage/src/model/RemoteUser.java | 11 + Application/Clavardage/src/model/User.java | 52 ++ .../Clavardage/src/view/Interface.java | 127 +++++ 12 files changed, 1170 insertions(+) create mode 100644 Application/Clavardage/src/controller/Controller.java create mode 100644 Application/Clavardage/src/controller/ListeningThread.java create mode 100644 Application/Clavardage/src/controller/ListeningThreadTCPChat.java create mode 100644 Application/Clavardage/src/controller/ListeningThreadTCPConnection.java create mode 100644 Application/Clavardage/src/controller/ListeningThreadUDP.java create mode 100644 Application/Clavardage/src/model/Chat.java create mode 100644 Application/Clavardage/src/model/LocalUser.java create mode 100644 Application/Clavardage/src/model/Message.java create mode 100644 Application/Clavardage/src/model/Msg_Text.java create mode 100644 Application/Clavardage/src/model/RemoteUser.java create mode 100644 Application/Clavardage/src/model/User.java create mode 100644 Application/Clavardage/src/view/Interface.java diff --git a/Application/Clavardage/src/controller/Controller.java b/Application/Clavardage/src/controller/Controller.java new file mode 100644 index 0000000..65c21c8 --- /dev/null +++ b/Application/Clavardage/src/controller/Controller.java @@ -0,0 +1,448 @@ +package controller; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.PrintWriter; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetAddress; +import java.net.Socket; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Date; + +import javax.swing.JOptionPane; + +import model.LocalUser; +import view.Interface; + +public class Controller { + + /*** CONSTANTES ***/ + final static int portUDPlistening_remoteUsr2 = 20002; // TO REMOVE when we use broadcast + final static int portUDPlistening_remoteUsr3 = 20003; // TO REMOVE when we use broadcast + + /*** ATTRIBUTS ***/ + private LocalUser myUser; + private Interface hisView; + private ListeningThreadUDP udp_connect_thread; + private ListeningThreadTCPConnection tcp_connect_thread; + private ArrayList tcp_chats_threads = new ArrayList(); // listes des utilisateurs actifs + + /** + * Constructor of Controller + * @parametres + * @param portUDPsend : int => le numéro de port pour envoyé ces informations lors d'un changements ou d'une nouvelle connexion + * @param portUDPlistening : int => le numéro de port pour recevoir les informations des nouveaux utilisateurs ou les changements + * @param portTCP : int => le numéro de port pour commencer une nouvelle conversation + * @descrition + *

+ * On récupère l'adresse de la machine, on demande un pseudo à l'utilisateur que l'on vérifie + * Une fois validé l'utilisateur devient actif : + * - écoute UDP pour les pseudos + * - écoute TCP pour de nouvelles conversation + * - notification aux autres utilisateurs actifs + *

+ */ + private Controller(int portUDPsend,int portUDPlistening,int portTCP) { + InetAddress addIP = null; + try + { + addIP = InetAddress.getLocalHost(); + } + catch(UnknownHostException e) { + JOptionPane.showMessageDialog(null ,"Could not find local address!"); + } + this.myUser = new LocalUser("Unknown",addIP,portUDPsend,portUDPlistening,portTCP); + + try { + this.myUser.setPseudo(this.initPseudo()); + } catch (IOException e) { + e.printStackTrace(); + } + + this.udp_connect_thread = new ListeningThreadUDP("UDP Listening thread",this.myUser); + this.udp_connect_thread.start(); + + this.tcp_connect_thread = new ListeningThreadTCPConnection("TCP main Listening thread",this.myUser); + this.tcp_connect_thread.start(); + + notify_remote_users(); + } + + /** + * Constructor of Controller + * @parametres + * @param portUDPsend : int => le numéro de port pour envoyé ces informations lors d'un changements ou d'une nouvelle connexion + * @param portUDPlistening : int => le numéro de port pour recevoir les informations des nouveaux utilisateurs ou les changements + * @param portTCP : int => le numéro de port pour commencer une nouvelle conversation + * @descrition + *

+ * On récupère l'adresse de la machine, on demande un pseudo à l'utilisateur que l'on vérifie + * Une fois validé l'utilisateur devient actif : + * - écoute UDP pour les pseudos + * - écoute TCP pour de nouvelles conversation + * - notification aux autres utilisateurs actifs + *

+ */ + private Controller(int portUDPsend,int portUDPlistening,int portTCP,String pseudo) { + InetAddress addIP = null; + try + { + addIP = InetAddress.getLocalHost(); + } + catch(UnknownHostException e) { + JOptionPane.showMessageDialog(null ,"Could not find local address!"); + } + this.myUser = new LocalUser(pseudo,addIP,portUDPsend,portUDPlistening,portTCP); + + this.udp_connect_thread = new ListeningThreadUDP("UDP Listening thread",this.myUser); + this.udp_connect_thread.start(); + + this.tcp_connect_thread = new ListeningThreadTCPConnection("TCP main Listening thread",this.myUser); + this.tcp_connect_thread.start(); + + notify_remote_users(); + } + + + + + /*** GETTERS ***/ + public LocalUser getMyUser() { + return myUser; + } + public Interface getHisView() { + return hisView; + } + public ListeningThreadUDP getUdp_connect_thread() { + return udp_connect_thread; + } + public ListeningThreadTCPConnection getTcp_connect_thread() { + return tcp_connect_thread; + } + public ArrayList getTcp_chats_threads() { + return tcp_chats_threads; + } + + /*** SETTERS ***/ + public void setMyUser(LocalUser myUser) { + this.myUser = myUser; + } + public void setHisView(Interface hisView) { + this.hisView = hisView; + } + public void setUdp_connect_thread(ListeningThreadUDP udp_connect_thread) { + this.udp_connect_thread = udp_connect_thread; + } + public void setTcp_connect_thread(ListeningThreadTCPConnection tcp_connect_thread) { + this.tcp_connect_thread = tcp_connect_thread; + } + public void setTcp_chats_threads(ArrayList tcp_chats_threads) { + this.tcp_chats_threads = tcp_chats_threads; + } + + + + /** + *

+ * Demande à l'utilisateur de rentrer un pseudo et valide de ce dernier en demandant aux + * utilisateurs distants leurs informations + *

+ */ + public String initPseudo() throws IOException { + String tmpPseudo = JOptionPane.showInputDialog(null, "Enter nickname:"); // Read user input + + while(!(this.validatePseudo(tmpPseudo))) { // On demande aux autres utilisateurs de nous envoyer leurs informations et on test si le pseudo est déjà utilisé + tmpPseudo = JOptionPane.showInputDialog(null, "Enter another nickname:"); // Read user input + } + + //sc1.close(); + JOptionPane.showMessageDialog(null ,"Your nickname : " + tmpPseudo + " is valid !"); + + return tmpPseudo; + } + + /** + *

+ * Demande à l'utilisateur de rentrer un pseudo et valide de ce dernier en demandant aux + * utilisateurs distants leurs informations. + * On regarde si le pseudo est bien différent de l'ancien + *

+ */ + private void changePseudo() throws IOException { + String oldPseudo = this.myUser.getPseudo(); //Saves the old one for comparison + + String tmpPseudo = JOptionPane.showInputDialog(null, "Enter nickname:"); // Read user input + + while(!(this.validatePseudo(tmpPseudo)) || tmpPseudo.equals(oldPseudo)) { + tmpPseudo = JOptionPane.showInputDialog(null, "Already exist, enter another nickname :"); // Read user input + } + + this.myUser.setPseudo(tmpPseudo); + + JOptionPane.showMessageDialog(null ,"Your new nickname : " + tmpPseudo + " is valid !"); + + this.notify_remote_users(); + } + + /** + *

+ * *tmpPseudo : String => Le pseudo à valider + *

+ * Envoi en broadcast (pour l'instant envoi sur les ports de notre ordinateur) d'une demande d'information + *

+ * On attend les réponses pendant 5 secondes + *

+ * On valide le pseudo en fonction des pseudos reçu + *

+ * On en profite pour ajouter les utilisateurs répondant à notre liste d'utilisateur distant (RemoteUser) + *

+ */ + public Boolean validatePseudo(String tmpPseudo) throws IOException { + + + // Call broadcast + InetAddress broadcastIP = InetAddress.getLocalHost(); // change to broadcast + //System.out.println(broadcastIP); + DatagramSocket dgramSocket = new DatagramSocket(this.myUser.getPortUDPsend(),this.myUser.getAddIP()); + byte[] buffer = new byte[256]; + + // Création du message à envoyer + String toSend = this.myUser.getAddIP()+":"+this.myUser.getPortUDPsend()+":test"; + + // Send to remote user 1 + DatagramPacket outPacket= new DatagramPacket(toSend.getBytes(), toSend.length(),broadcastIP, portUDPlistening_remoteUsr2); + dgramSocket.send(outPacket); + + // Send to remote user 2 + outPacket= new DatagramPacket(toSend.getBytes(), toSend.length(),broadcastIP, portUDPlistening_remoteUsr3); + dgramSocket.send(outPacket); + + // Initialisation des variables de la boucle + Boolean valid = true; + + DatagramPacket inPacket; + String response = null; + String[] tabresponse= new String [4]; + dgramSocket.setSoTimeout(1000); + Boolean arecu; + + System.out.print("Wait for pseudo validation ...\n"); + + int nbReponse =0; + Date oldDate = new Date(); + Date newDate = new Date(); + while( (newDate.getTime()-oldDate.getTime()) < 5000 && valid) { + + nbReponse++; + inPacket= new DatagramPacket(buffer, buffer.length); + + arecu=true; + try{ + dgramSocket.receive(inPacket); + }catch (Exception e) { + arecu=false; + } + buffer = inPacket.getData(); + response = new String(buffer); + + if(arecu) { + // On découpe la réponse en tableau de string ([adresseIP,tcpPort,nickname]) + tabresponse = response.split(":"); + + // Affichage de la réponse + System.out.println("Remote user n°"+nbReponse+ + "\nIP : "+tabresponse[0]+ + "\nn°Port : "+tabresponse[1]+ + "\npseudo : "+tabresponse[2]); + + // Si reception on ajoute l'utilisateur à notre liste d'utilisateur distant + this.myUser.addRemoteUser(InetAddress.getByName(tabresponse[0].split("/")[1]),Integer.parseInt(tabresponse[1]),tabresponse[2]); + valid= (tmpPseudo.compareTo(tabresponse[2])!=0); // On regarde la différence entre notre pseudo et le pseudo reçu + + } + + newDate = new Date(); + } + dgramSocket.close(); + + if(!valid) { + JOptionPane.showMessageDialog(null ,"Nickname : "+tmpPseudo +" is taken !"); + } + + return valid; + } + + /** + *

+ * En utilisant le port UDP d'envoi, on envoie en broadcast les informations nous concernant + *

+ */ + public void notify_remote_users() { + // Création du socket d'envoi d'information + DatagramSocket dgramSocket= null; + try { + dgramSocket= new DatagramSocket(this.myUser.getPortUDPsend(),this.myUser.getAddIP()); + } catch (IOException e) { + e.printStackTrace(); + } + + // Construction du message à envoyer + String toSend = this.myUser.getAddIP().toString()+":"+this.myUser.getPortTCP()+":"+this.myUser.getPseudo()+":test"; + + DatagramPacket outPacket =null; + + // Send information to usr2 + if(this.myUser.getPortUDPlistening()!=portUDPlistening_remoteUsr2) { + outPacket = new DatagramPacket(toSend.getBytes(), toSend.length(),this.myUser.getAddIP(), portUDPlistening_remoteUsr2); + try { + dgramSocket.send(outPacket); + } catch (IOException e) { + e.printStackTrace(); + } + } + + + // Send information to usr3 + if(this.myUser.getPortUDPlistening()!=portUDPlistening_remoteUsr3) { + + outPacket= new DatagramPacket(toSend.getBytes(), toSend.length(),this.myUser.getAddIP(), portUDPlistening_remoteUsr3); + try { + dgramSocket.send(outPacket); + } catch (IOException e) { + e.printStackTrace(); + } + } + dgramSocket.close(); + } + + public void TCPmessage(int index) throws IOException { + Socket link=null; + String s1; + try { + link=new Socket(this.myUser.getRemoteUsersList().get(index).getAddIP(),this.myUser.getRemoteUsersList().get(index).getPortTCP()); + + System.out.println("Server is listening on port"+this.myUser.getPortTCP()+"of localhost"); + }catch(IOException e) { + + System.out.println("Server is not listening on port"+this.myUser.getPortTCP()+" of localhost"); + + } + BufferedReader in=null; + try { + in = new BufferedReader(new InputStreamReader(link.getInputStream())); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + try { + PrintWriter out = new PrintWriter(link.getOutputStream(),true); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + String input; + String s2 = (this.myUser.getPseudo()+" reçoit un message"); + try { + while (!(input=in.readLine()).equals("end")) { + System.out.print("client_recoit:"+input); + } + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + /*or (int i=0; i<4; i++) { + System.out.println("client envoie"); + out.println("coucou \n"); + } + out.println("end");*/ + try { + link.close(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + + /** + *

+ * Laisse l'utilisateur choisir parmis la liste d'utilisateurs actifs celui avec lequel il souhaite échanger via un chat + *

+ */ + public void getOneActiveUser() throws IOException { + this.printRemoteUserList(); + int index=Integer.parseInt(JOptionPane.showInputDialog(null, "Please, enter index of one active user that you saw on the list to start a conversation with:")); + + if (index >= 0 && index + * Affichage de la liste d'utilisateurs actifs avec leurs index dans la liste + *

+ */ + public void printRemoteUserList() { + System.out.println("Internal list of active remote users:"); + + for(int i=0; i nom du thread + * @param myUser : User => utilisateur utilisant ce thread + * @description + *

+ *

+ */ + public ListeningThreadTCPChat(String s,LocalUser myUser,Socket socket) { + super(s,myUser); + this.socket=socket; + + } + + /* run + * @description + *

+ * + *

+ */ + public void run() { + Socket link = this.socket; + try { + BufferedReader in =new BufferedReader(new InputStreamReader(link.getInputStream())); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + PrintWriter out=null; + try { + out = new PrintWriter(link.getOutputStream(),true); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); + Date date = new Date(); + System.out.println(myUser.getPseudo()+" envoie un message"); + out.println(dateFormat.format(date)); + out.println("end"); + String input; + /*while (!(input=in.readLine()).equals("end")) { + System.out.print("server_recoit:"+input); + }*/ + try { + link.close(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + /* close + * @description + *

+ * ferme le socket d'écoute TCP pour le chat + * interrupt TCP listening thread pour le chat + *

+ */ + public void close() { + try { + this.socket.close(); + } catch (IOException e1) { + e1.printStackTrace(); + } + System.out.println("End of listing thread UDP ("+this.myUser.getPseudo()+")"); + try { + this.interrupt(); + }catch (Exception e){ + e.printStackTrace(); + } + } +} diff --git a/Application/Clavardage/src/controller/ListeningThreadTCPConnection.java b/Application/Clavardage/src/controller/ListeningThreadTCPConnection.java new file mode 100644 index 0000000..f50ac2e --- /dev/null +++ b/Application/Clavardage/src/controller/ListeningThreadTCPConnection.java @@ -0,0 +1,91 @@ +package controller; + +import model.LocalUser; + +import java.io.IOException; +import java.net.ServerSocket; +import java.net.Socket; + +public class ListeningThreadTCPConnection extends ListeningThread{ + + private Socket socket_tcp=null; + + /* CONSTRUCTOR OF ListeningThreadTCPConnection + * @parametres + * @param s : String => nom du thread + * @param myUser : User => utilisateur utilisant ce thread + * @description + *

+ *

+ */ + public ListeningThreadTCPConnection(String s,LocalUser myUser) { + super(s,myUser); + + } + + public void accept(ServerSocket servSocket) throws IOException { + Socket socket_tcp= servSocket.accept(); + ListeningThreadTCPChat threadtcpchat = new ListeningThreadTCPChat("Chat_with_"+myUser.getPseudo(),myUser,socket_tcp); + threadtcpchat.start(); + threadtcpchat.interrupt(); + + + } + + /* run + * @description + *

+ * écoutes les messages TCP tant que l'utilisateur est actif + * Traitement + * Si réception d'une demande, créer un thread pour la conversation + *

+ */ + public void run(){ + + // Tant que l'utilisateur est actif on attends la demande de nouvelle conversation + while(true) { + + ServerSocket servSocket=null; + try { + servSocket = new ServerSocket(myUser.getPortTCP()); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + try { + this.accept(servSocket); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + + } + + } + + /* close + * @description + *

+ * ferme le socket d'écoute TCO + * interrupt UDP listening threadS + *

+ */ + public void close() { + try { + this.socket_tcp.close(); + } catch (IOException e1) { + e1.printStackTrace(); + } + System.out.println("End of listing thread TCP ("+this.myUser.getPseudo()+")"); + try { + this.interrupt(); + }catch (Exception e){ + e.printStackTrace(); + } + } + +} + + diff --git a/Application/Clavardage/src/controller/ListeningThreadUDP.java b/Application/Clavardage/src/controller/ListeningThreadUDP.java new file mode 100644 index 0000000..3089b26 --- /dev/null +++ b/Application/Clavardage/src/controller/ListeningThreadUDP.java @@ -0,0 +1,121 @@ +package controller; + +import model.LocalUser; + +import java.io.IOException; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetAddress; +import java.net.UnknownHostException; + +public class ListeningThreadUDP extends ListeningThread{ + + private DatagramSocket dgramSocket = null; + + + /* CONSTRUCTOR OF UserListeningThreadUDP + * @parametres + * @param s : String => nom du thread + * @param user : User => utilisateur utilisant ce thread + * @description + *

+ * Appel du constructeur de la classe hérité + * Création d'un socket d'écoute UDP + *

+ */ + public ListeningThreadUDP(String s,LocalUser myUser) { + super(s,myUser); + try { + this.dgramSocket = new DatagramSocket(this.myUser.getPortUDPlistening(),this.myUser.getAddIP()); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /* run + * @description + *

+ * écoutes les messages UDP tant que l'utilisateur est actif + * Traitement + * 1) Si demande d'information => envoi ses informations + * 2) Si réception d'information => ajoute les informations + *

+ */ + public void run(){ + + // Tant que l'utilisateur est actif on attends les messages des nouveaux utilisateurs et changements des utilisateurs actifs + while(true) { + + // Réception du message + byte[] buffer = new byte[256]; + DatagramPacket inPacket= new DatagramPacket(buffer, buffer.length); + try { + dgramSocket.receive(inPacket); + } catch (Exception e) { + e.printStackTrace(); + } + buffer = inPacket.getData(); + + // Traitement en fonction du message reçu + String receiveMsg = new String(buffer); + String [] tabMsg = receiveMsg.split(":"); + + + // si demande d'information d'un nouvel utilisateur + if(tabMsg.length==3) { + InetAddress itsIP = null; + try { + itsIP = InetAddress.getByName(tabMsg[0].split("/")[1]); // On récupère l'adresse IP de l'utilisateur distant + } catch (UnknownHostException e1) { + // TODO Auto-generated catch block + e1.printStackTrace(); + } + int senderUDPport = Integer.parseInt(tabMsg[1]); // On récupère le port UDP de l'utilisateur distant + + String toSend = myUser.getAddIP().toString()+":"+myUser.getPortTCP()+":"+myUser.getPseudo()+":test"; + DatagramPacket outPacket= new DatagramPacket(toSend.getBytes(), toSend.length(),itsIP, senderUDPport); + + try { + dgramSocket.send(outPacket); + } catch (IOException e) { + e.printStackTrace(); + } + } + + // Si un nouvel utilisateur passe en mode actif ou changement d'information + else { + try { + // On récupère l'adresse IP et le port TCP de l'utilisateur distant et ajout à la liste de l'utilisateur utilisant ce thread + this.myUser.addRemoteUser(InetAddress.getByName(tabMsg[0].split("/")[1]),Integer.parseInt(tabMsg[1]),tabMsg[2]); + } catch (NumberFormatException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (UnknownHostException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + + } + + + } + + /* close + * @description + *

+ * Ferme le socket d'écoute UDP + * Interrompt le thread d'écoute UDP + *

+ */ + public void close() { + this.dgramSocket.close(); + System.out.println("End of listing thread UDP ("+this.myUser.getPseudo()+")"); + try { + this.interrupt(); + }catch (Exception e){ + e.printStackTrace(); + } + } +} diff --git a/Application/Clavardage/src/model/Chat.java b/Application/Clavardage/src/model/Chat.java new file mode 100644 index 0000000..e1c2064 --- /dev/null +++ b/Application/Clavardage/src/model/Chat.java @@ -0,0 +1,50 @@ +package model; + +import java.util.ArrayList; + +public class Chat { + + /*** ATTRIBUTS ***/ + private int localUser_portTCP; + private int remoteUser_portTCP; + private ArrayList remoteUsersChatList = new ArrayList(); // listes des utilisateurs sur ce chat + + /** + * Constructor of Chat (local) + * @parametres + * @param remoteUser : remoteUser => référence de l'utilisateur distant + * @param localUser_portTCP : int => le numéro de port TCP d'écoute de la conversation de l'utilisateur local + * @param remoteUser_portTCP : int => le numéro de port TCP d'écoute de la conversation de l'utilisateur distant + * @description + *

+ * + *

+ */ + public Chat(RemoteUser rm,int localUser_portTCP,int remoteUser_portTCP) { + this.localUser_portTCP = localUser_portTCP; + this.remoteUser_portTCP = remoteUser_portTCP; + remoteUsersChatList.add(rm); + } + + /*** GETTERS ***/ + public int getLocalUser_portTCP() { + return localUser_portTCP; + } + public int getRemoteUser_portTCP() { + return remoteUser_portTCP; + } + public ArrayList getRemoteUsersChatList() { + return remoteUsersChatList; + } + + /*** SETTERS ***/ + public void setLocalUser_portTCP(int localUser_portTCP) { + this.localUser_portTCP = localUser_portTCP; + } + public void setRemoteUser_portTCP(int remoteUser_portTCP) { + this.remoteUser_portTCP = remoteUser_portTCP; + } + public void setRemoteUsersChatList(ArrayList remoteUsersChatList) { + this.remoteUsersChatList = remoteUsersChatList; + } +} diff --git a/Application/Clavardage/src/model/LocalUser.java b/Application/Clavardage/src/model/LocalUser.java new file mode 100644 index 0000000..a38c52e --- /dev/null +++ b/Application/Clavardage/src/model/LocalUser.java @@ -0,0 +1,95 @@ +package model; + +import java.net.InetAddress; +import java.util.ArrayList; + + +public class LocalUser extends User{ + + + /*** ATTRIBUTS ***/ + private int portUDPsend; + private int portUDPlistening; + private ArrayList remoteUsersList = new ArrayList(); // listes des utilisateurs actifs + private ArrayList chats = new ArrayList(); + + /** + * Constructor of LocalUser + * @parametres + * @param pseudo : String + * @param addIP : InetAddress + * @param portUDPsend : int => le numéro de port pour envoyé ces informations lors d'un changements ou d'une nouvelle connexion + * @param portUDPlistening : int => le numéro de port pour recevoir les informations des nouveaux utilisateurs ou les changements + * @param portTCP : int => le numéro de port pour commencer une nouvelle conversation + * @description + *

+ * + *

+ */ + public LocalUser(String pseudo,InetAddress addIP,int portUDPsend,int portUDPlistening,int portTCP){ + super(pseudo,addIP,portTCP); + this.portUDPsend = portUDPsend; + this.portUDPlistening = portUDPlistening; + } + + /*** GETTERS ***/ + public int getPortUDPsend() { + return portUDPsend; + } + public int getPortUDPlistening() { + return portUDPlistening; + } + public ArrayList getRemoteUsersList() { + return remoteUsersList; + } + public ArrayList getChats() { + return chats; + } + + /*** SETTERS ***/ + public void setPortUDPsend(int portUDPsend) { + this.portUDPsend = portUDPsend; + } + public void setPortUDPlistening(int portUDPlistening) { + this.portUDPlistening = portUDPlistening; + } + + + + /** + * @parameters + * @param remoteUserIP : InetAddress => l'adresse IP de l'utilisateur distant + * @param remoteUserPortTCP : int => le numéro de port TCP d'écoute de l'utilisateur distant + * @param remoteUserPseudo : String => le pseudo de l'utilisateur distant + *

+ * Ajout ou mise à jour l'utilisateur distant dans notre liste d'utilisateur distant + *

+ */ + public void addRemoteUser(InetAddress remoteUserIP, int remoteUserPortTCP,String remoteUserPseudo) { + RemoteUser tmpRemoteUser = new RemoteUser(remoteUserPseudo,remoteUserIP,remoteUserPortTCP); + int index = this.remoteUsersList.indexOf(tmpRemoteUser); + if(index!=-1) { + System.out.println("("+this.pseudo+") - "+"MAJ, IP(port) of user : "+remoteUserPseudo+" => "+remoteUserIP+"("+remoteUserPortTCP+")"); + this.remoteUsersList.set(index,tmpRemoteUser); + } + else { + System.out.println("("+this.pseudo+") - "+"Add new user IP(port) of user : "+remoteUserPseudo+" => "+remoteUserIP+"("+remoteUserPortTCP+")"); + this.remoteUsersList.add(tmpRemoteUser); + } + } + + + /** + * @parameters + * @param remoteUser : remoteUser => référence de l'utilisateur distant + * @param localUser_portTCP : int => le numéro de port TCP d'écoute de la conversation de l'utilisateur local + * @param remoteUser_portTCP : int => le numéro de port TCP d'écoute de la conversation de l'utilisateur distant + *

+ * Ajout ou mise à jour l'utilisateur distant dans notre liste d'utilisateur distant + *

+ */ + public void addChats(RemoteUser rm,int localUser_portTCP,int remoteUser_portTCP) { + Chat newChat= new Chat(rm,localUser_portTCP,remoteUser_portTCP); + this.chats.add(newChat); + } +} diff --git a/Application/Clavardage/src/model/Message.java b/Application/Clavardage/src/model/Message.java new file mode 100644 index 0000000..c07ad47 --- /dev/null +++ b/Application/Clavardage/src/model/Message.java @@ -0,0 +1,46 @@ +package model; + +import java.net.InetAddress; +import java.util.Date; +import java.text.DateFormat; +import java.text.SimpleDateFormat; + +public abstract class Message { + + /*** ATTRIBUTS ***/ + private Date date; + private InetAddress autorIP; + + /** + * Constructor of Message + * @parametres + * @param authorIP : InetAddress + * @description + *

+ * + *

+ */ + public Message(InetAddress autorIP) { + this.autorIP = autorIP; + DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"); + this.date = new Date(); + } + /*** GETTERS ***/ + public Date getDate() { + return date; + } + public InetAddress getAutorIP() { + return autorIP; + } + + /*** SETTERS ***/ + public void setDate(Date date) { + this.date = date; + } + public void setAutorIP(InetAddress autorIP) { + this.autorIP = autorIP; + } + + + public abstract Object getMessage(); +} diff --git a/Application/Clavardage/src/model/Msg_Text.java b/Application/Clavardage/src/model/Msg_Text.java new file mode 100644 index 0000000..954f400 --- /dev/null +++ b/Application/Clavardage/src/model/Msg_Text.java @@ -0,0 +1,22 @@ +package model; + +import java.net.InetAddress; + +public class Msg_Text extends Message{ + + /*** ATTRIBUT ***/ + private String text; + + public Msg_Text(InetAddress autorIP,String text) { + super(autorIP); + this.text = text; + } + + @Override + public String getMessage() { + return this.text; + } + + + +} diff --git a/Application/Clavardage/src/model/RemoteUser.java b/Application/Clavardage/src/model/RemoteUser.java new file mode 100644 index 0000000..8e1fc6e --- /dev/null +++ b/Application/Clavardage/src/model/RemoteUser.java @@ -0,0 +1,11 @@ +package model; + +import java.net.InetAddress; + +public class RemoteUser extends User{ + + public RemoteUser(String pseudo, InetAddress addIP, int portTCP) { + super(pseudo, addIP, portTCP); + } + +} diff --git a/Application/Clavardage/src/model/User.java b/Application/Clavardage/src/model/User.java new file mode 100644 index 0000000..ec2b2b2 --- /dev/null +++ b/Application/Clavardage/src/model/User.java @@ -0,0 +1,52 @@ +package model; + +import java.net.*; + +public abstract class User { + + /*** ATTRIBUTS ***/ + protected String pseudo; + protected InetAddress addIP; + protected int portTCP; + + /** + * Constructor of User (local) + * @parametres + * @param pseudo : String + * @param addIP : InetAddress + * @param portTCP : int => le numéro de port pour commencer une nouvelle conversation + * @description + *

+ * + *

+ */ + public User(String pseudo,InetAddress addIP,int portTCP){ + this.pseudo = pseudo; + this.addIP=addIP; + this.portTCP=portTCP; + } + + + /*** GETTERS ***/ + public String getPseudo() { + return pseudo; + } + public InetAddress getAddIP() { + return addIP; + } + public int getPortTCP() { + return portTCP; + } + + /*** SETTERS ***/ + public void setPseudo(String pseudo) { + this.pseudo = pseudo; + } + public void setAddIP(InetAddress addIP) { + this.addIP = addIP; + } + public void setPortTCP(int portTCP) { + this.portTCP = portTCP; + } + +} diff --git a/Application/Clavardage/src/view/Interface.java b/Application/Clavardage/src/view/Interface.java new file mode 100644 index 0000000..b8a0fb4 --- /dev/null +++ b/Application/Clavardage/src/view/Interface.java @@ -0,0 +1,127 @@ +package view; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; + +public class Interface implements ActionListener { + + private String Pseudolabeltext = ""; + final JLabel Pseudolabel = new JLabel("Pseudo: " + Pseudolabeltext); + private JTextField PseudotextField; + private JButton convertPseudo; + + //Specifies the look and feel to use. Valid values: + //null (use the default), "Metal", "System", "Motif", "GTK+" + final static String LOOKANDFEEL = null; + + public Component createComponents() { + PseudotextField = new JTextField(); + PseudotextField.setColumns(10); + PseudotextField.setText("Enter pseudo"); + + convertPseudo = new JButton("Convert Pseudo"); + convertPseudo.addActionListener(this); + + Pseudolabel.setLabelFor(PseudotextField); + + /* + * An easy way to put space between a top-level container + * and its contents is to put the contents in a JPanel + * that has an "empty" border. + */ + JPanel pane = new JPanel(new GridLayout(0, 1)); + pane.add(PseudotextField); + pane.add(Pseudolabel); + pane.add(convertPseudo); + pane.setBorder(BorderFactory.createEmptyBorder( + 30, //top + 30, //left + 10, //bottom + 30) //right + ); + + return pane; + } + + // Modify the event handler code depending on which button is pressed. + // If the 1st button is pressed, increase the numClicks value by 1, else + // increase the value by 1000. + public void actionPerformed(ActionEvent e) { + String texteUtilisateur = PseudotextField.getText(); + Pseudolabel.setText("Pseudo: " + texteUtilisateur); + } + + private static void initLookAndFeel() { + + // Swing allows you to specify which look and feel your program uses- + // -Java, + // GTK+, Windows, and so on as shown below. + String lookAndFeel = null; + + if (LOOKANDFEEL != null) { + if (LOOKANDFEEL.equals("Metal")) { + lookAndFeel = UIManager.getCrossPlatformLookAndFeelClassName(); + } else if (LOOKANDFEEL.equals("System")) { + lookAndFeel = UIManager.getSystemLookAndFeelClassName(); + } else if (LOOKANDFEEL.equals("Motif")) { + lookAndFeel = "com.sun.java.swing.plaf.motif.MotifLookAndFeel"; + } else if (LOOKANDFEEL.equals("GTK+")) { //new in 1.4.2 + lookAndFeel = "com.sun.java.swing.plaf.gtk.GTKLookAndFeel"; + } else { + System.err.println("Unexpected value of LOOKANDFEEL specified: " + LOOKANDFEEL); + lookAndFeel = UIManager.getCrossPlatformLookAndFeelClassName(); + } + + try {UIManager.setLookAndFeel(lookAndFeel); + } catch (ClassNotFoundException e) { + System.err.println("Couldn't find class for specified look and feel:" + lookAndFeel); + System.err.println("Did you include the L&F library in the class path?"); + System.err.println("Using the default look and feel."); + } catch (UnsupportedLookAndFeelException e) { + System.err.println("Can't use the specified look and feel (" + lookAndFeel+ ") on this platform."); + System.err.println("Using the default look and feel."); + } catch (Exception e) { + System.err.println("Couldn't get specified look and feel (" + lookAndFeel + "), for some reason."); + System.err.println("Using the default look and feel."); + e.printStackTrace(); + } + } + } + + /** + * Create the GUI and show it. For thread safety, + * this method should be invoked from the + * event-dispatching thread. + */ + private static void createAndShowGUI() { + //Set the look and feel. + initLookAndFeel(); + + //Make sure we have nice window decorations. + JFrame.setDefaultLookAndFeelDecorated(true); + + //Create and set up the window. + JFrame frame = new JFrame("SwingApplication"); + frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + Interface app = new Interface(); + Component contents = app.createComponents(); + frame.getContentPane().add(contents, BorderLayout.CENTER); + + //Display the window. + frame.pack(); + frame.setVisible(true); + } + /* + public static void main(String[] args) { + //Schedule a job for the event-dispatching thread: + //creating and showing this application’s GUI. + javax.swing.SwingUtilities.invokeLater(new Runnable() { + public void run() { + createAndShowGUI(); + } + }); + }*/ +} +