gallois/Clavardage
2
0
Ответвление 0
Код Задачи Слияния Выпуски Вики Активность

lien entre chat et message

Просмотр исходного кода
Этот коммит содержится в:
Alexandre Gonzalvez 2020-12-09 12:34:15 +01:00
родитель 93e418dbee
коммит 601e040edd
11 изменённых файлов: 7 добавлений и 935 удалений
Показать статистику Скачать .patch Скачать .diff Показать все файлы Свернуть все файлы

7
Application/Clavardage/bin/.gitignore предоставленный
Просмотреть файл

@ -1,4 +1,3 @@
/UserListeningThreadTCP.class
/UserListeningThreadUDP.class
/UserConnexionthreadTCP.class
/Database.class
/controller/
/model/
/view/

Двоичные данные
Application/Clavardage/bin/RemoteUser.class
Просмотреть файл

Двоичный файл не отображается.

Двоичные данные
Application/Clavardage/bin/User.class
Просмотреть файл

Двоичный файл не отображается.

9
Application/Clavardage/src/Database.java
Просмотреть файл

@ -1,9 +0,0 @@
public class Database {
private User myUser;
public void Database() {
Connection con=null;
}
}

124
Application/Clavardage/src/Interface.java
Просмотреть файл

@ -1,124 +0,0 @@
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();
}
});
}
}

67
Application/Clavardage/src/RemoteUser.java
Просмотреть файл

@ -1,67 +0,0 @@
import java.net.InetAddress;
public class RemoteUser {
InetAddress addIP;
int portTCP;
String pseudo;
/*** CONSTRUCTOR of RemoteUser ***/
public RemoteUser(InetAddress remoteUserIP, int remoteUserPortTCP,String pseudo) {
this.addIP=remoteUserIP;
this.portTCP=remoteUserPortTCP;
this.pseudo=pseudo;
}
/*** GETTERS ***/
public InetAddress getRemoteUserIP() {
return addIP;
}
public int getRemoteUserPort() {
return portTCP;
}
public String getPseudo() {
return pseudo;
}
/*** SETTERS ***/
public void setRemoteUserIP(InetAddress remoteUserIP) {
this.addIP = remoteUserIP;
}
public void setRemoteUserPort(int remoteUserPort) {
this.portTCP = remoteUserPort;
}
public void setRemotePseudo(String remoteUserpseudo) {
this.pseudo = remoteUserpseudo;
}
/*** OVERRIDE METHODS ***/
/*
* equals
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
RemoteUser other = (RemoteUser) obj;
if (addIP == null) {
if (other.addIP != null)
return false;
} else if (!addIP.equals(other.addIP))
return false;
if (portTCP != other.portTCP)
return false;
return true;
}
}

467
Application/Clavardage/src/User.java
Просмотреть файл

@ -1,467 +0,0 @@
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.JOptionPane;
import java.util.ArrayList; // import the ArrayList class
public class User{
/*** 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
/*** VARIABLES ***/
protected InetAddress addIP;
protected String pseudo;
protected int portUDPsend;
protected int portUDPlistening;
protected int portTCP;
protected boolean actif;
protected ArrayList<RemoteUser> remoteUserList = new ArrayList<RemoteUser>(); // listes des utilisateurs actifs
protected ArrayList<RemoteUser> userChatList = new ArrayList<RemoteUser>(); // listes des utilisateurs avec qui un chat est actif
protected UserListeningThreadUDP threadListeningUDP; // UDP listening thread (pour répondre aux nouveaux utilisateurs)
protected UserListeningThreadTCP threadListeningTCP; // TCP listening thread (pour commencer une nouvelle conversation)
/**
* Constructor of User (local)
* $parametres
* * portUDPsend : int => le numéro de port pour envoyé ces informations lors d'un changements ou d'une nouvelle connexion
* * portUDPlistening : int => le numéro de port pour recevoir les informations des nouveaux utilisateurs ou les changements
* * portTCP : int => le numéro de port pour commencer une nouvelle conversation
* <p>
* On récupère l'adresse de la machine, le numéro de port à utiliser, on demande un pseudo à l'utilisateur
* que l'on vérifie, une fois validé, l'utilisateur devient actif (Début de l'écoute UDP pour les pseudos et notification aux autres utilisateurs actifs)
* </p>
*/
public User(int portUDPsend,int portUDPlistening,int portTCP) throws IOException{
try
{
this.addIP = InetAddress.getLocalHost();
}
catch(UnknownHostException e) {
JOptionPane.showMessageDialog(null ,"Could not find local address!");
}
this.portUDPsend = portUDPsend;
this.portUDPlistening = portUDPlistening;
this.portTCP = portTCP;
this.initPseudo();
this.active();
}
/**
* Constructor of User (simulation of remote user)
* $parametres
* * portUDPsend : int => le numéro de port pour envoyé ces informations lors d'un changements ou d'une nouvelle connexion
* * portUDPlistening : int => le numéro de port pour recevoir les informations des nouveaux utilisateurs ou les changements
* * portTCP : int => le numéro de port pour commencer une nouvelle conversation
* * pseudo : String => le pseudo avec lequel on initie l'utilisateur distant (! pas de vérification)
* <p>
* On récupère l'adresse de la machine, le numéro de port à utiliser, on demande un pseudo à l'utilisateur
* que l'on vérifie, une fois validé, l'utilisateur devient actif (Début de l'écoute UDP pour les pseudos
* et notification aux autres utilisateurs actifs)
* </p>
*/
public User(int portUDPsend,int portUDPlistening, int portTCP,String pseudo) {
try
{
this.addIP = InetAddress.getLocalHost();
}
catch(UnknownHostException e) {
JOptionPane.showMessageDialog(null ,"Could not find local address!");
}
this.portUDPsend = portUDPsend;
this.portUDPlistening = portUDPlistening;
this.portTCP = portTCP;
this.pseudo = pseudo;
this.active();
}
/*** GETTERS ***/
public InetAddress getAddIP() {
return addIP;
}
public String getPseudo() {
return pseudo;
}
public int getPortTCP() {
return portTCP;
}
public int getPortUDPlistening() {
return portUDPlistening;
}
public int getPortUDPsend() {
return portUDPsend;
}
public boolean isActif() {
return actif;
}
/*** SETTERS ***/
public void setAddIP(InetAddress addIP) {
this.addIP = addIP;
}
public void setPortTCP(int portTCP) {
this.portTCP = portTCP;
}
public void setPortUDPlistening(int portUDPlistening) {
this.portUDPlistening = portUDPlistening;
}
public void setPortUDPsend(int portUDPsend) {
this.portUDPsend = portUDPsend;
}
/**
* <p>
* 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
* </p>
*/
private void setPseudo() throws IOException {
String oldPseudo = this.pseudo; //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.pseudo = tmpPseudo;
//myObj.close();
JOptionPane.showMessageDialog(null ,"Your new nickname : " + tmpPseudo + " is valid !");
notify_remote_user();
}
/**
* <p>
* Demande à l'utilisateur de rentrer un pseudo et valide de ce dernier en demandant aux
* utilisateurs distants leurs informations
* </p>
*/
public void 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
}
this.pseudo = tmpPseudo;
//sc1.close();
JOptionPane.showMessageDialog(null ,"Your nickname : " + tmpPseudo + " is valid !");
}
public void TCPmessage(int index) throws IOException {
Socket link=null;
String s1;
try {
link=new Socket(this.userChatList.get(index).addIP,this.userChatList.get(index).portTCP);
System.out.println("Server is listening on port"+this.portTCP+"of localhost");
}catch(IOException e) {
System.out.println("Server is not listening on port"+this.portTCP+" 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.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();
}
}
/**
* <p>
* *tmpPseudo : String => Le pseudo à valider
*</p><p>
* Envoi en broadcast (pour l'instant envoi sur les ports de notre ordinateur) d'une demande d'information
*</p><p>
* On attend les réponses pendant 5 secondes
*</p><p>
* On valide le pseudo en fonction des pseudos reçu
*</p><p>
* On en profite pour ajouter les utilisateurs répondant à notre liste d'utilisateur distant (RemoteUser)
* </p>
*/
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.portUDPsend,this.addIP);
byte[] buffer = new byte[256];
// Création du message à envoyer
String toSend = this.getAddIP()+":"+this.portUDPsend+":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.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;
}
/**
* <p>
* *remoteUserIP : InetAddress => l'adresse IP de l'utilisateur distant
* </p><p>
* *remoteUserPortTCP : int => le numéro de port TCP d'écoute de l'utilisateur distant
* </p><p>
* *remoteUserPseudo : String => le pseudo de l'utilisateur distant
* </p><p>
* Ajout ou mise à jour l'utilisateur distant dans notre liste d'utilisateur distant
* </p>
*/
public void addRemoteUser(InetAddress remoteUserIP, int remoteUserPortTCP,String remoteUserPseudo) {
RemoteUser tmpRemoteUser = new RemoteUser(remoteUserIP,remoteUserPortTCP,remoteUserPseudo);
int index = this.remoteUserList.indexOf(tmpRemoteUser);
if(index!=-1) {
System.out.println("("+this.pseudo+") - "+"MAJ, IP(port) of user : "+remoteUserPseudo+" => "+remoteUserIP+"("+remoteUserPortTCP+")");
this.remoteUserList.set(index,tmpRemoteUser);
}
else {
System.out.println("("+this.pseudo+") - "+"Add new user IP(port) of user : "+remoteUserPseudo+" => "+remoteUserIP+"("+remoteUserPortTCP+")");
this.remoteUserList.add(tmpRemoteUser);
}
}
/**
* <p>
* En utilisant le port UDP d'envoi, on envoie en broadcast les informations nous concernant
* </p>
*/
public void notify_remote_user() {
// Création du socket d'envoi d'information
DatagramSocket dgramSocket= null;
try {
dgramSocket= new DatagramSocket(portUDPsend,this.addIP);
} catch (IOException e) {
e.printStackTrace();
}
// Construction du message à envoyer
String toSend = this.addIP.toString()+":"+this.portTCP+":"+this.pseudo+":test";
DatagramPacket outPacket =null;
// Send information to usr2
if(this.portUDPlistening!=portUDPlistening_remoteUsr2) {
outPacket = new DatagramPacket(toSend.getBytes(), toSend.length(),this.addIP, portUDPlistening_remoteUsr2);
try {
dgramSocket.send(outPacket);
} catch (IOException e) {
e.printStackTrace();
}
}
// Send information to usr3
if(this.portUDPlistening!=portUDPlistening_remoteUsr3) {
outPacket= new DatagramPacket(toSend.getBytes(), toSend.length(),this.addIP, portUDPlistening_remoteUsr3);
try {
dgramSocket.send(outPacket);
} catch (IOException e) {
e.printStackTrace();
}
}
dgramSocket.close();
}
/**
* <p>
* On démarre un thread d'écoute UDP pour répondre au nouveaux utilisateurs,
* </p><p>
* On démarre un thread d'écoute TCP pour commencer une conversation avec les utilisateurs actifs,
* </p><p>
* On notifie les utilisateurs distants actifs de notre passage en mode actif (envoi de nos informations)
* </p>
*/
private void active() {
this.threadListeningUDP = new UserListeningThreadUDP("UDP Listening thread",this);
this.threadListeningUDP.start();
this.threadListeningTCP = new UserListeningThreadTCP("TCP main Listening thread",this);
this.threadListeningTCP.start();
notify_remote_user();
this.actif=true;
}
/**
* <p>
* Affichage de la liste d'utilisateurs actifs avec leurs index dans la liste
* </p>
*/
public void printRemoteUserList() {
System.out.println("Internal list of active remote users:");
for(int i=0; i<this.remoteUserList.size(); i++) {
System.out.println("- ("+i+") Username: " + this.remoteUserList.get(i).getPseudo());
}
}
/**
* <p>
* Laisse l'utilisateur choisir parmis la liste d'utilisateurs actifs celui avec lequel il souhaite échanger via un chat
*</p>
*/
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<remoteUserList.size()) {
if(userChatList.contains(remoteUserList.get(index))) {
JOptionPane.showMessageDialog(null ,"User "+remoteUserList.get(index).getPseudo()+" is already in chat with you");
}
else {
userChatList.add(remoteUserList.get(index));
JOptionPane.showMessageDialog(null ,"New chat with "+remoteUserList.get(index).getPseudo());
}
}
else {
JOptionPane.showMessageDialog(null ,"Wrong index (no active at index number "+index+" )");
}
this.TCPmessage(index);
//sc2.close();
}
public static void main(String[] args) throws IOException, InterruptedException {
// Création des utilisateurs
User usr2 = new User(12226,portUDPlistening_remoteUsr2,22222,"Mike"); // simulation d'un utilisateur distant n1
User usr3 = new User(12224,portUDPlistening_remoteUsr3,22223,"Alice"); // simulation d'un utilisateur distant n2
User usr1 = new User(12225,20001,22221); // Notre utilisateur local
// Fonction appelé par notre utilisateur local
usr1.getOneActiveUser();
usr1.setPseudo();
// On attends 5 secondes
System.out.println("Sleep mode for 5 seconds");
Thread.sleep(5000);
// On ferme les différents threads et socket d'écoute
usr1.threadListeningUDP.close();
usr2.threadListeningUDP.close();
usr3.threadListeningUDP.close();
usr1.threadListeningTCP.close();
usr2.threadListeningTCP.close();
usr3.threadListeningTCP.close();
JOptionPane.showMessageDialog(null ,"End");
}
}

55
Application/Clavardage/src/UserConnexionthreadTCP.java
Просмотреть файл

@ -1,55 +0,0 @@
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.DatagramSocket;
import java.net.Socket;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class UserConnexionthreadTCP extends Thread{
private User myUser;
private Socket socket;
public UserConnexionthreadTCP(String s,User user,Socket socket) {
super(s);
this.myUser = user;
this.socket=socket;
}
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();
}
}
}

95
Application/Clavardage/src/UserListeningThreadTCP.java
Просмотреть файл

@ -1,95 +0,0 @@
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.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class UserListeningThreadTCP extends Thread{
private User myUser;
//private DatagramSocket dgramSocket=null;
/* CONSTRUCTOR OF UserListeningThreadTCP
* $parametres
* * s : String => nom du thread
* * user : User => utilisateur utilisant ce thread
* $description
* Création d'un socket d'écoute
*/
public UserListeningThreadTCP(String s,User user) {
super(s);
this.myUser = user;
/* try {
this.dgramSocket = new DatagramSocket(this.myUser.getPortTCP(),this.myUser.getAddIP());
} catch (IOException e) {
e.printStackTrace();
}
*/
}
public void accept(ServerSocket servSocket) throws IOException {
Socket socket_tcp= servSocket.accept();
UserConnexionthreadTCP threadtcp= new UserConnexionthreadTCP("Chat_with_"+myUser.getPseudo(),myUser,socket_tcp);
threadtcp.start();
threadtcp.interrupt();
}
/* run
* $description
* écoutes les messages TCP tant que l'utilisateur est actif
* Traitement
* Si réception d'une demande, créer un
*/
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.portTCP);
} 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 UDP
* interrupt UDP listening threadS
*/
public void close() {
// this.dgramSocket.close();
System.out.println("End of listing thread TCP ("+this.myUser.getPseudo()+")");
try {
this.interrupt();
}catch (Exception e){
e.printStackTrace();
}
}
}

114
Application/Clavardage/src/UserListeningThreadUDP.java
Просмотреть файл

@ -1,114 +0,0 @@
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class UserListeningThreadUDP extends Thread{
private User myUser;
private DatagramSocket dgramSocket=null;
/* CONSTRUCTOR OF UserListeningThreadUDP
* $parametres
* * s : String => nom du thread
* * user : User => utilisateur utilisant ce thread
* $description
* Création d'un socket d'écoute
*/
public UserListeningThreadUDP(String s,User user) {
super(s);
this.myUser = user;
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
* interrupt UDP listening threadS
*/
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();
}
}
}

4
Application/Clavardage/src/model/Chat.java
Просмотреть файл

@ -8,6 +8,7 @@ public class Chat {
private int localUser_portTCP;
private int remoteUser_portTCP;
private ArrayList<RemoteUser> remoteUsersChatList = new ArrayList<RemoteUser>(); // listes des utilisateurs sur ce chat
private ArrayList<Message> messages = new ArrayList<Message>();
/**
* Constructor of Chat (local)
@ -36,6 +37,9 @@ public class Chat {
public ArrayList<RemoteUser> getRemoteUsersChatList() {
return remoteUsersChatList;
}
public ArrayList<Message> getMessages() {
return messages;
}
/*** SETTERS ***/
public void setLocalUser_portTCP(int localUser_portTCP) {