alartigu/ChatApp-AL-NM
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Amelioration des méthodes de connexion et de modification de pseudo

Browse source
This commit is contained in:
Auriane Lartigue 2020-12-04 18:25:38 +01:00
parent f436ef2c18
commit 27abecae5d
9 changed files with 230 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
Implementation/src/ChatApp.class
View file

Binary file not shown.

172
Implementation/src/ChatApp.java
View file

@ -16,7 +16,7 @@ import java.util.concurrent.Executors;
/** /**
* <p> * <p>
* Classe récapitulant toutes les actions possibles pour un utilisateur * Classe recapitulant toutes les actions possibles pour un utilisateur
* </p> * </p>
*/ */
@ -24,19 +24,11 @@ public class ChatApp {
/* Liste des utilisateurs actifs */ /* Liste des utilisateurs actifs */
private ListUtilisateurs actifUsers ; private ListUtilisateurs actifUsers ;
private static ArrayList<Integer> ListPort = new ArrayList<Integer>();
/* Map on l'on stocke localement les historiques des messages */
private Map<String,Historique> mapHistorique ; private Map<String,Historique> mapHistorique ;
/* ChatApp est associe a un utilisateur */
public static ArrayList<Integer> getListPort() {
return ListPort;
}
/* ChatApp est associé à un utilisateur */
private Utilisateur me; private Utilisateur me;
/** /**
@ -50,17 +42,21 @@ public class ChatApp {
// Recuperer adresse IP de l'utilisateur // Recuperer adresse IP de l'utilisateur
InetAddress ip = null ; InetAddress ip = null ;
try { try {
//ip = InetAddress.getByName("192.168.1.72");
ip = InetAddress.getLocalHost(); ip = InetAddress.getLocalHost();
} catch (UnknownHostException e) { } catch (UnknownHostException e) {
e.printStackTrace(); e.printStackTrace();
} }
//ip.getHostAddress();
this.me = new Utilisateur(pseudo,port,ip); this.me = new Utilisateur(pseudo,port,ip);
this.actifUsers.addList(getMe()); this.actifUsers.addList(getMe());
this.mapHistorique = new HashMap<String,Historique>() ; this.mapHistorique = new HashMap<String,Historique>() ;
} }
/**
* Mettre a jour dans Maphistorique, l'historique avec un utilisateur dont le nom est pseudo
*
* @param pseudo Pseudo de l'utilisateur
* @param h nouvel Historique entre les deux utilisateurs
*/
public void majHistorique(String pseudo,Historique h) { public void majHistorique(String pseudo,Historique h) {
getMapHistorique().put(h.getUser2().getPseudo(),h); getMapHistorique().put(h.getUser2().getPseudo(),h);
} }
@ -74,112 +70,100 @@ public class ChatApp {
* @param nouveau correspond au nouveau pseudo * @param nouveau correspond au nouveau pseudo
*/ */
public void modifierPseudo(String nouveau) throws IOException { public void modifierPseudo(String nouveau) throws IOException {
// @ de broadcast du réseau de l'utilisateur me
InetAddress broadcastAdress = InetAddress.getLoopbackAddress(); // A MODIFIER
// Message que l'on envoie à tous les utilisateurs actifs // Message que l'on envoie à tous les utilisateurs actifs
String broadcastMessage = "Modification Pseudo\n" + this.getMe().toString() + "\n" + nouveau + "\n"; String broadcastMessage = "Demande Modification Pseudo\n" + this.getMe().toString() + "\n" + nouveau + "\n";
/*for(Integer p : ListPort ) { UDPEchange.EnvoiBroadcast(broadcastMessage);
if(!(p.equals(this.getMe().getPort()))) try {
{ Thread.sleep(1000);
UDPEchange.connexion(broadcastAdress,broadcastMessage, p); /* L'utilisateur doit attendre la reponse de tous les utilisateurs connectes
* pour savoir si son pseudo est accepte
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
if (UDPEchange.getPseudoValide()) {
System.out.println("Modification pseudo reussie");
//Envoi un msg en broadcast a tout les utilisateurs pour les prevenir de son nouveau pseudo//
broadcastMessage = "Modification pseudo reussie\n" + this.getMe().toString() + "\n" + nouveau + "\n";
UDPEchange.EnvoiBroadcast(broadcastMessage);
//-------Change son propre nom d'utilisateur-------//
this.getActifUsers().modifierList(this.getMe().getPseudo(), nouveau);
this.getMe().setPseudo(nouveau);
System.out.println("Changement pseudo accepte, nouvelle liste des utilisateurs actifs:");
this.getActifUsers().afficherListeUtilisateurs();
}
else
{
System.out.println("Connexion echoue");
System.exit(1) ; // A MODIFIER NORMALEMENT ON LUI DEMANDE DE CHOISIR UN NV MDP
} }
}*/
UDPEchange.connexion(broadcastAdress,broadcastMessage, 1234);
} }
/** /**
* Methode appelée lors de la connexion d'un nouvel utilisateur. * Methode appelee lors de la connexion d'un nouvel utilisateur.
* Il va prévenir les utilisateurs du réseau de son arrivée. * Il va prevenir les utilisateurs du reseau de son arrivee.
* *
*/ */
public void connexion() throws IOException { public void connexion() throws IOException {
// @ de broadcast du réseau de l'utilisateur me
InetAddress broadcastAdress = InetAddress.getLoopbackAddress(); // A MODIFIER
// Message que l'on envoie à tous les utilisateurs actifs // Message que l'on envoie à tous les utilisateurs actifs
String broadcastMessage = "Connexion\n" + this.getMe().toString() ; String broadcastMessage = "Connexion\n" + this.getMe().toString() ;
/*for(Integer p : ListPort ) { UDPEchange.EnvoiBroadcast(broadcastMessage);
if(!(p.equals(this.getMe().getPort()))) try {
{ Thread.sleep(1000); // L'utilisateur doit attendre la reponse de tous les utilisateurs connectes
UDPEchange.connexion(broadcastAdress,broadcastMessage, p); } catch (InterruptedException e) {
e.printStackTrace();
}
if (UDPEchange.getConnecte()) {
System.out.println("Connexion reussie");
}
else
{
System.out.println("Connexion echoue");
System.exit(1) ; // A MODIFIER NORMALEMENT ON LUI DEMANDE DE CHOISIR UN NV MDP
} }
}*/
UDPEchange.connexion(broadcastAdress,broadcastMessage, 1234);
} }
/** /**
* Methode appelée lors de la déconnexion de l'utilisateur. * Methode appelee lors de la deconnexion de l'utilisateur.
* Il va prévenir les utilisateurs du réseau de son départ. * Il va prevenir les utilisateurs du reseau de son depart.
* *
*/ */
public void deconnexion() throws IOException { public void deconnexion() throws IOException {
// @ de broadcast du réseau de l'utilisateur me
InetAddress broadcastAdress = InetAddress.getLoopbackAddress(); // A MODIFIER
// Message que l'on envoie à tous les utilisateurs actifs // Message que l'on envoie à tous les utilisateurs actifs
String broadcastMessage = "Deconnexion\n" + this.getMe().toString() ; String broadcastMessage = "Deconnexion\n" + this.getMe().toString() ;
/*for(Integer p : ListPort ) { UDPEchange.EnvoiBroadcast(broadcastMessage);
if(!(p.equals(this.getMe().getPort())))
{
UDPEchange.connexion(broadcastAdress,broadcastMessage, p);
}
}*/
UDPEchange.connexion(broadcastAdress,broadcastMessage, 1234);
} }
public static void main (String[] args) throws IOException { /**
//Integer p = 2345 ; * Getter
ChatApp app = new ChatApp(args[0],Integer.parseInt(args[1])) ; * @return Utilisateur associee a ChatApp
InetAddress localHost = InetAddress.getLocalHost() ; */
System.out.println("Mon adress: "+ localHost.toString());
ListPort.add(1234);
ListPort.add(3000);
ListPort.add(4000);
/*for(InetAddress broadcastAddr : UDPEchange.listAllBroadcastAddresses()) {
System.out.println("Broadcast sent with address " + broadcastAddr.toString());
}*/
//InetAddress broadcastAddress = InterfaceAddress.getBroadcast();
//System.out.println("Mon adresse:" + localHost.toString());
ExecutorService exec = Executors.newFixedThreadPool(1000);
exec.submit(new Runner(app));
try {
app.connexion();
} catch (IOException e) {
e.printStackTrace();
}
if (app.getMe().getPort() == 4000) {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
app.modifierPseudo("Doudou");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
app.modifierPseudo("Eliot");
/*try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
app.deconnexion(); */
}
}
public Utilisateur getMe() { public Utilisateur getMe() {
return me; return me;
} }
/**
* Getter
* @return Liste des utilisateurs actifs associee a ChatApp
*/
public ListUtilisateurs getActifUsers() { public ListUtilisateurs getActifUsers() {
return actifUsers; return actifUsers;
} }
/**
* Getter
* @return la map des historiques
*/
public Map<String,Historique> getMapHistorique() { public Map<String,Historique> getMapHistorique() {
return mapHistorique; return mapHistorique;
} }
/**
* Obtenir l'historique entre deux utilisateurs
* @param pseudo Pseudo de l'utilisateur dont on souhaite obtenir l'historique
* @return Un historique
*/
public Historique getHist(String pseudo) { public Historique getHist(String pseudo) {
Historique h = this.mapHistorique.get(pseudo); Historique h = this.mapHistorique.get(pseudo);
if( h != null) { if( h != null) {
@ -191,8 +175,24 @@ public class ChatApp {
} }
} }
public static void main (String[] args) throws IOException {
ChatApp app = new ChatApp(args[0],Integer.parseInt(args[1])) ;
ExecutorService exec = Executors.newFixedThreadPool(1000);
exec.submit(new Runner(app));
try {
app.connexion();
} catch (IOException e) {
e.printStackTrace();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
app.modifierPseudo("Jean");
}
} }

BIN
Implementation/src/ListUtilisateurs.class
View file

Binary file not shown.

4
Implementation/src/ListUtilisateurs.java
View file

@ -74,6 +74,10 @@ public class ListUtilisateurs {
this.afficherListeUtilisateurs(); this.afficherListeUtilisateurs();
} }
public Boolean appartient(Utilisateur u) {
return this.actifUsers.contains(u);
}
/** /**

BIN
Implementation/src/Runner.class
View file

Binary file not shown.

BIN
Implementation/src/RunnerUDP.class
View file

Binary file not shown.

BIN
Implementation/src/UDPEchange.class
View file

Binary file not shown.

228
Implementation/src/UDPEchange.java
View file

@ -12,93 +12,95 @@ import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
/** /**
* <p> * <p>
* Classe representant les échanges UDP entre utilisateurs. * Classe representant les echanges UDP entre utilisateurs.
* </p> * </p>
*/ */
public class UDPEchange { public class UDPEchange {
private static Boolean Connecte = true; // True si l'utilisateur peut se connecter avec ce nom d'utilisateur , False sinon private static Boolean Connecte = true;
// True si l'utilisateur peut se connecter avec ce nom d'utilisateur , False sinon
/**
* Getter
* @return le boolean connecte (True s'il peut se connecter avec ce nom d'utilisateur , False sinon)
*/
public static Boolean getConnecte() { public static Boolean getConnecte() {
return Connecte; return Connecte;
} }
/**
* Setter
* @param value La nouvelle valeur du boolean de connexion
*/
public static void setConnecte(Boolean value) { public static void setConnecte(Boolean value) {
Connecte = value ; Connecte = value ;
} }
private static Boolean PseudoValide = true;
// True si l'utilisateur a (ou demande) un pseudo valide , False sinon
/**
* Getter
* @return le boolean PseudoValide (True s'il peut utiliser ce pseudo , False sinon)
*/
public static Boolean getPseudoValide() {
return PseudoValide;
}
/**
* Setter
* @param value La nouvelle valeur du boolean concernant le pseudo valide
*/
public static void setPseudoValide(Boolean value) {
PseudoValide = value ;
}
/** /**
* <p> * <p>
* Méthode permettant d'envoyer un message à tout les utilisateurs * Méthode permettant d'envoyer un message à tout les utilisateurs
* à l'aide du protocole UDP * a l'aide du protocole UDP
* </p> * </p>
* * @param broadcastMessage correspond au message a transmettre aux utilisateurs
* @param broadcastAdress l'addresse de broadcast du réseau
* @param broadcastMessage correspond au message à transmettre aux utilisateurs
* @param port : port destination
*
*/ */
public static void connexion( InetAddress broadcastAdress , String broadcastMessage , Integer port) throws IOException { public static void EnvoiBroadcast(String broadcastMessage) throws IOException {
int port = 1234 ;
// Envoie en broadcast à tous les utilsateurs // Envoie en broadcast à tous les utilsateurs
for (InetAddress broadcastAddr : listAllBroadcastAddresses()) { for (InetAddress broadcastAddr : listAllBroadcastAddresses()) {
DatagramSocket socket = new DatagramSocket(); DatagramSocket socket = new DatagramSocket();
socket.setBroadcast(true); socket.setBroadcast(true);
byte[]buffer = broadcastMessage.getBytes(); byte[]buffer = broadcastMessage.getBytes();
DatagramPacket packet = new DatagramPacket( buffer, buffer.length, broadcastAddr, port ); DatagramPacket packet = new DatagramPacket( buffer, buffer.length, broadcastAddr,port);
socket.send(packet); socket.send(packet);
socket.close(); socket.close();
System.out.println("Broadcast sent with address " + broadcastAddr.toString()); System.out.println("Broadcast sent with address " + broadcastAddr.toString());
try {
Thread.sleep(1000); // L'utilisateur doit attendre la réponse de tous les utilisateurs connectes
} catch (InterruptedException e) {
e.printStackTrace();
}
if (UDPEchange.getConnecte()) {
System.out.println("Connexion reussie");
}
else
{
System.out.println("Connexion echoue");
System.exit(1) ; // A MODIFIER NORMALEMENT ON LUI DEMANDE DE CHOISIR UN NV MDP
}
}
/*
DatagramSocket socket = new DatagramSocket();
socket.setBroadcast(true);
byte[]buffer = broadcastMessage.getBytes();
DatagramPacket packet = new DatagramPacket( buffer, buffer.length, broadcastAdress, port );
socket.send(packet);
socket.close();
*/
System.out.println("***********Message envoye***********"); System.out.println("***********Message envoye***********");
System.out.println("Dest Ip: " + broadcastAdress.toString()); System.out.println("Dest Ip: " + broadcastAddr.toString());
System.out.println("Dest port: " + port.toString()); System.out.println("Dest port: " + String.valueOf(port));
System.out.println("Contenu: "); System.out.println("Contenu: ");
System.out.println(broadcastMessage); System.out.println(broadcastMessage);
System.out.println("************************************"); System.out.println("************************************");
} }
}
/** /**
* <p> * <p>
* Méthode permettant la reception de messages d'utilisateurs * Methode permettant la reception de messages d'utilisateurs
* à l'aide du protocole UDP * a l'aide du protocole UDP
* </p> * </p>
*
* @param app L'application de chat de l'utilisateur qui receptionne le message * @param app L'application de chat de l'utilisateur qui receptionne le message
*
*/ */
public static void ecouteUDP(ChatApp app) public static void ecouteUDP(ChatApp app)
{ {
DatagramSocket socket = null; DatagramSocket socket = null;
ExecutorService exec = Executors.newFixedThreadPool(1000); ExecutorService exec = Executors.newFixedThreadPool(1000);
try { try {
socket = new DatagramSocket(app.getMe().getPort()); socket = new DatagramSocket(1234);
} catch (SocketException e1) { } catch (SocketException e1) {
e1.printStackTrace(); e1.printStackTrace();
} }
byte buffer[] = new byte[1024]; byte buffer[] = new byte[1024];
System.out.println("Ecoute sur le port: "+app.getMe().getPort().toString()); System.out.println("Ecoute sur le port: 1234");
while(true) while(true)
{ {
DatagramPacket data = new DatagramPacket(buffer,buffer.length); DatagramPacket data = new DatagramPacket(buffer,buffer.length);
@ -107,29 +109,39 @@ public class UDPEchange {
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); e.printStackTrace();
} }
// Un thread est lancé à chaque reception d'un message // Un thread est lance à chaque reception d'un message
System.out.println("Message recu!"); System.out.println("Message recu!");
exec.submit(new RunnerUDP(data,app)); exec.submit(new RunnerUDP(data,app));
} }
} }
public static void envoiUnicast( InetAddress broadcastAdress , String broadcastMessage , Integer port) throws IOException { /**
// Envoie en broadcast à tous les utilsateurs * <p>
* Methode permettant d'envoyer un message a utilisateur en particulier
* a l'aide du protocole UDP
* </p>
* @param Adress l'addresse de l'utilisateur
* @param Message correspond au message à transmettre a l'utilisateur
*/
public static void envoiUnicast( InetAddress Adress , String Message ) throws IOException {
DatagramSocket socket = new DatagramSocket(); DatagramSocket socket = new DatagramSocket();
byte[]buffer = broadcastMessage.getBytes(); byte[]buffer = Message.getBytes();
//DatagramPacket packet = new DatagramPacket( buffer, buffer.length, InetAddress.getLoopbackAddress(), port ); DatagramPacket packet = new DatagramPacket( buffer, buffer.length, Adress, 1234 );
DatagramPacket packet = new DatagramPacket( buffer, buffer.length, broadcastAdress, port );
socket.send(packet); socket.send(packet);
socket.close(); socket.close();
System.out.println("***********Message envoye***********"); System.out.println("***********Message envoye***********");
System.out.println("Dest Ip: " + broadcastAdress.toString()); System.out.println("Dest Ip: " + Adress.toString());
System.out.println("Dest port: " + port.toString()); System.out.println("Dest port: " + String.valueOf(1234));
System.out.println("Contenu: "); System.out.println("Contenu: ");
System.out.println(broadcastMessage); System.out.println(Message);
System.out.println("************************************"); System.out.println("************************************");
} }
/**
* <p>
* Methode permettant de recuperer la liste des adresses de broadcast, chacune associer à une interface de la machine
* </p>
*/
static List<InetAddress> listAllBroadcastAddresses() throws SocketException { static List<InetAddress> listAllBroadcastAddresses() throws SocketException {
List<InetAddress> broadcastList = new ArrayList<>(); List<InetAddress> broadcastList = new ArrayList<>();
Enumeration<NetworkInterface> interfaces Enumeration<NetworkInterface> interfaces
@ -155,8 +167,8 @@ public class UDPEchange {
/** /**
* <p> * <p>
* Classe implémentant l'interface Runnable. * Classe implementant l'interface Runnable.
* Contient les traitements à executer dans un thread lancer par des méthodes de la class UDPEchange * Contient les traitements a executer dans un thread lancer par des methodes de la class UDPEchange
* </p> * </p>
*/ */
class RunnerUDP implements Runnable { class RunnerUDP implements Runnable {
@ -170,7 +182,7 @@ class RunnerUDP implements Runnable {
/** /**
* <p> * <p>
* Méthode qui redefinie les traitements qui seront exécutés dans le thread: * Methode qui redefinie les traitements qui seront executes dans le thread:
* Met à jour la liste des utilisateurs actifs * Met à jour la liste des utilisateurs actifs
* </p> * </p>
* *
@ -184,10 +196,10 @@ class RunnerUDP implements Runnable {
System.out.println("**********************************"); System.out.println("**********************************");
String Type = received.split("\n")[0]; String Type = received.split("\n")[0];
//************************************************************************************************************************ //****************************************************************************************************
//************************************************************************************************************************* //****************************************************************************************************
//****************************************Demande de connexion**************************************** //****************************************Demande de connexion****************************************
//************************************************************************************************************************ //****************************************************************************************************
//**************************************** //****************************************
if (Type.equals("Connexion")) { // un utilisateur vient d'arriver sur le reseau if (Type.equals("Connexion")) { // un utilisateur vient d'arriver sur le reseau
System.out.println("Reception d'une demande de connexion"); System.out.println("Reception d'une demande de connexion");
@ -207,7 +219,7 @@ class RunnerUDP implements Runnable {
reponse += app.getMe().toString(); reponse += app.getMe().toString();
try { try {
UDPEchange.envoiUnicast(u.getIp(),reponse,u.getPort()); UDPEchange.envoiUnicast(u.getIp(),reponse);
}catch(IOException e) }catch(IOException e)
{ {
System.out.println("Echec de l'envoi du message"); System.out.println("Echec de l'envoi du message");
@ -216,11 +228,11 @@ class RunnerUDP implements Runnable {
( app.getActifUsers() ).afficherListeUtilisateurs(); ( app.getActifUsers() ).afficherListeUtilisateurs();
} }
} }
//************************************************************************************************************************ //*******************************************************************************************************
//************************************************************************************************************************* //*******************************************************************************************************
//****************************************Reponse d'une connexion**************************************** //****************************************Reponse d'une connexion****************************************
//************************************************************************************************************************ //*******************************************************************************************************
//************************************************************************************************************************ //*******************************************************************************************************
if (Type.equals("Reponse Connexion")) { // Un utilisateur te repond suite à ta demande de connexion if (Type.equals("Reponse Connexion")) { // Un utilisateur te repond suite à ta demande de connexion
@ -235,71 +247,75 @@ class RunnerUDP implements Runnable {
} }
} }
//************************************************************************************************************************ //*******************************************************************************************************************
//************************************************************************************************************************* //*******************************************************************************************************************
//****************************************Demande de modification d'un pseudo**************************************** //****************************************Demande de modification d'un pseudo****************************************
//************************************************************************************************************************ //*******************************************************************************************************************
//************************************************************************************************************************ //*******************************************************************************************************************
if (Type.equals("Modification Pseudo")) { if (Type.equals("Demande Modification Pseudo")) {
if(( app.getActifUsers() ).verifierUnicite(received.split("\n")[2])) { Utilisateur Source = Utilisateur.stringToUtilisateur(received.split("\n")[1]);
( app.getActifUsers() ).modifierList(received.split("\n")[1],received.split("\n")[2]); if (! Source.equals(this.app.getMe())) { // On envoit en broadcast mais on ne souhaite pas recevoir de message de nous même
Utilisateur Destination = Utilisateur.stringToUtilisateur(received.split("\n")[1]); String nouveau = received.split("\n")[2] ;
String Message = "Bon Choix Pseudo\n" + received.split("\n")[2] ; String Message = "";
System.out.println(Message); if(( app.getActifUsers() ).verifierUnicite(nouveau)) {
try { Message = "Bon Choix Pseudo\n" + nouveau ;
//UDPEchange.envoiUnicast(Destination.getIp(),Message, Destination.getPort());
UDPEchange.envoiUnicast(InetAddress.getLoopbackAddress(),Message, 4000);
} catch (IOException e) {
e.printStackTrace();
}
} }
else { else {
Utilisateur Destination = ( app.getActifUsers() ).getPseudoList(received.split("\n")[1]); Message = "Mauvais Choix Pseudo\n" ;
String Message = "Mauvais Choix Pseudo\n" ; }
System.out.println(Message); System.out.println(Message);
try { try {
UDPEchange.envoiUnicast(Destination.getIp(),Message, Destination.getPort()); UDPEchange.envoiUnicast(Source.getIp(),Message);
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
( app.getActifUsers() ).afficherListeUtilisateurs();
} }
//************************************************************************************************************************ //************************************************************************************************************
//************************************************************************************************************************* //************************************************************************************************************
//**************************************** Modification pseudo reussi ****************************************
//************************************************************************************************************
//************************************************************************************************************
if (Type.equals("Modification pseudo reussi")) {
Utilisateur Source = Utilisateur.stringToUtilisateur(received.split("\n")[1]);
if (! Source.equals(this.app.getMe())) { // On envoit en broadcast mais on ne souhaite pas recevoir de message de nous même
String nouveau = received.split("\n")[2] ;
if(app.getActifUsers().appartient(Source)) { // On verifie d'abord que Source appartient bien a la liste des utilisateurs actifs
app.getActifUsers().modifierList(Source.getPseudo(), nouveau);
}
{
// Suite a une perte d'un message lors d'une connexion l'utilisateur Source n'apparait pas dans la liste
app.getActifUsers().addList(Source);
}
}
}
//*********************************************************************************************************
//*********************************************************************************************************
//****************************************Mauvais choix d'un pseudo**************************************** //****************************************Mauvais choix d'un pseudo****************************************
//************************************************************************************************************************ //*********************************************************************************************************
//**************************************** //*********************************************************************************************************
if (Type.equals("Mauvais Choix Pseudo")) { if (Type.equals("Mauvais Choix Pseudo")) {
System.out.println("Ce choix de pseudo est déjà pris il te faut en choisir un autre"); System.out.println("Ce choix de pseudo est déjà pris il te faut en choisir un autre");
UDPEchange.setPseudoValide(false);
} }
//************************************************************************************************************************ //******************************************************************************************************************
//************************************************************************************************************************* //******************************************************************************************************************
//****************************************Bon choix d'un pseudo**************************************** //****************************************Bon choix d'un pseudo*****************************************************
//************************************************************************************************************************ //******************************************************************************************************************
//************************************************************************************************************************ //******************************************************************************************************************
if (Type.equals("Bon Choix Pseudo")) { if (Type.equals("Bon Choix Pseudo")) {
// Il n'y a rien a faire ici
( app.getActifUsers() ).supprimerList(app.getMe());
app.getMe().setPseudo(received.split("\n")[1]);
( app.getActifUsers() ).addList(app.getMe());
System.out.println("Changement pseudo accepte, nouvelle liste des utilisateurs actifs:");
app.getActifUsers().afficherListeUtilisateurs();
} }
//************************************************************************************************************************ //*********************************************************************************************************
//************************************************************************************************************************* //*********************************************************************************************************
//****************************************Demande d'une deconnexion**************************************** //****************************************Demande d'une deconnexion****************************************
//************************************************************************************************************************ //*********************************************************************************************************
//************************************************************************************************************************ //*********************************************************************************************************
if (Type.equals("Deconnexion")) { if (Type.equals("Deconnexion")) {
( app.getActifUsers() ).supprimerList(Utilisateur.stringToUtilisateur(received.split("\n")[1])); ( app.getActifUsers() ).supprimerList(Utilisateur.stringToUtilisateur(received.split("\n")[1]));

BIN
Implementation/src/Utilisateur.class
View file

Binary file not shown.