Compare commits
3 commits
f436ef2c18
...
38e8703d5a
| Author | SHA1 | Date | |
|---|---|---|---|
| 38e8703d5a | |||
| 4c8f699024 | |||
| 27abecae5d |
12 changed files with 327 additions and 212 deletions
|
|
@ -1,6 +1,10 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<classpath>
|
||||
<classpathentry kind="src" path="src"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-13">
|
||||
<attributes>
|
||||
<attribute name="module" value="true"/>
|
||||
</attributes>
|
||||
</classpathentry>
|
||||
<classpathentry kind="output" path="bin"/>
|
||||
</classpath>
|
||||
|
|
|
|||
10
Implementation/.settings/org.eclipse.jdt.core.prefs
Normal file
10
Implementation/.settings/org.eclipse.jdt.core.prefs
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
eclipse.preferences.version=1
|
||||
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
|
||||
org.eclipse.jdt.core.compiler.codegen.targetPlatform=13
|
||||
org.eclipse.jdt.core.compiler.compliance=13
|
||||
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
|
||||
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
|
||||
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
|
||||
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
|
||||
org.eclipse.jdt.core.compiler.release=enabled
|
||||
org.eclipse.jdt.core.compiler.source=13
|
||||
Binary file not shown.
|
|
@ -16,7 +16,7 @@ import java.util.concurrent.Executors;
|
|||
|
||||
/**
|
||||
* <p>
|
||||
* Classe récapitulant toutes les actions possibles pour un utilisateur
|
||||
* Classe recapitulant toutes les actions possibles pour un utilisateur
|
||||
* </p>
|
||||
*/
|
||||
|
||||
|
|
@ -24,19 +24,11 @@ public class ChatApp {
|
|||
|
||||
/* Liste des utilisateurs actifs */
|
||||
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 ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
public static ArrayList<Integer> getListPort() {
|
||||
return ListPort;
|
||||
}
|
||||
|
||||
/* ChatApp est associé à un utilisateur */
|
||||
/* ChatApp est associe a un utilisateur */
|
||||
private Utilisateur me;
|
||||
|
||||
/**
|
||||
|
|
@ -50,17 +42,21 @@ public class ChatApp {
|
|||
// Recuperer adresse IP de l'utilisateur
|
||||
InetAddress ip = null ;
|
||||
try {
|
||||
//ip = InetAddress.getByName("192.168.1.72");
|
||||
ip = InetAddress.getLocalHost();
|
||||
} catch (UnknownHostException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
//ip.getHostAddress();
|
||||
this.me = new Utilisateur(pseudo,port,ip);
|
||||
this.actifUsers.addList(getMe());
|
||||
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) {
|
||||
getMapHistorique().put(h.getUser2().getPseudo(),h);
|
||||
}
|
||||
|
|
@ -74,112 +70,100 @@ public class ChatApp {
|
|||
* @param nouveau correspond au nouveau pseudo
|
||||
*/
|
||||
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
|
||||
String broadcastMessage = "Modification Pseudo\n" + this.getMe().toString() + "\n" + nouveau + "\n";
|
||||
/*for(Integer p : ListPort ) {
|
||||
if(!(p.equals(this.getMe().getPort())))
|
||||
{
|
||||
UDPEchange.connexion(broadcastAdress,broadcastMessage, p);
|
||||
}
|
||||
}*/
|
||||
UDPEchange.connexion(broadcastAdress,broadcastMessage, 1234);
|
||||
String broadcastMessage = "Demande Modification Pseudo\n" + this.getMe().toString() + "\n" + nouveau + "\n";
|
||||
UDPEchange.EnvoiBroadcast(broadcastMessage);
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
/* 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
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Methode appelée lors de la connexion d'un nouvel utilisateur.
|
||||
* Il va prévenir les utilisateurs du réseau de son arrivée.
|
||||
* Methode appelee lors de la connexion d'un nouvel utilisateur.
|
||||
* Il va prevenir les utilisateurs du reseau de son arrivee.
|
||||
*
|
||||
*/
|
||||
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
|
||||
String broadcastMessage = "Connexion\n" + this.getMe().toString() ;
|
||||
/*for(Integer p : ListPort ) {
|
||||
if(!(p.equals(this.getMe().getPort())))
|
||||
{
|
||||
UDPEchange.connexion(broadcastAdress,broadcastMessage, p);
|
||||
UDPEchange.EnvoiBroadcast(broadcastMessage);
|
||||
try {
|
||||
Thread.sleep(1000); // L'utilisateur doit attendre la reponse de tous les utilisateurs connectes
|
||||
} catch (InterruptedException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}*/
|
||||
UDPEchange.connexion(broadcastAdress,broadcastMessage, 1234);
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Methode appelée lors de la déconnexion de l'utilisateur.
|
||||
* Il va prévenir les utilisateurs du réseau de son départ.
|
||||
* Methode appelee lors de la deconnexion de l'utilisateur.
|
||||
* Il va prevenir les utilisateurs du reseau de son depart.
|
||||
*
|
||||
*/
|
||||
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
|
||||
String broadcastMessage = "Deconnexion\n" + this.getMe().toString() ;
|
||||
/*for(Integer p : ListPort ) {
|
||||
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 ;
|
||||
ChatApp app = new ChatApp(args[0],Integer.parseInt(args[1])) ;
|
||||
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(); */
|
||||
}
|
||||
UDPEchange.EnvoiBroadcast(broadcastMessage);
|
||||
}
|
||||
|
||||
/**
|
||||
* Getter
|
||||
* @return Utilisateur associee a ChatApp
|
||||
*/
|
||||
public Utilisateur getMe() {
|
||||
return me;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Getter
|
||||
* @return Liste des utilisateurs actifs associee a ChatApp
|
||||
*/
|
||||
public ListUtilisateurs getActifUsers() {
|
||||
return actifUsers;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Getter
|
||||
* @return la map des historiques
|
||||
*/
|
||||
public Map<String,Historique> getMapHistorique() {
|
||||
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) {
|
||||
Historique h = this.mapHistorique.get(pseudo);
|
||||
if( h != null) {
|
||||
|
|
@ -190,9 +174,25 @@ public class ChatApp {
|
|||
return h ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
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");
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -72,6 +72,10 @@ public class ListUtilisateurs {
|
|||
}
|
||||
}
|
||||
this.afficherListeUtilisateurs();
|
||||
}
|
||||
|
||||
public Boolean appartient(Utilisateur u) {
|
||||
return this.actifUsers.contains(u);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -12,93 +12,95 @@ import java.util.concurrent.ExecutorService;
|
|||
import java.util.concurrent.Executors;
|
||||
/**
|
||||
* <p>
|
||||
* Classe representant les échanges UDP entre utilisateurs.
|
||||
* Classe representant les echanges UDP entre utilisateurs.
|
||||
* </p>
|
||||
*/
|
||||
|
||||
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() {
|
||||
return Connecte;
|
||||
}
|
||||
|
||||
/**
|
||||
* Setter
|
||||
* @param value La nouvelle valeur du boolean de connexion
|
||||
*/
|
||||
public static void setConnecte(Boolean 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>
|
||||
* Méthode permettant d'envoyer un message à tout les utilisateurs
|
||||
* à l'aide du protocole UDP
|
||||
* a l'aide du protocole UDP
|
||||
* </p>
|
||||
*
|
||||
* @param broadcastAdress l'addresse de broadcast du réseau
|
||||
* @param broadcastMessage correspond au message à transmettre aux utilisateurs
|
||||
* @param port : port destination
|
||||
*
|
||||
* @param broadcastMessage correspond au message a transmettre aux utilisateurs
|
||||
*/
|
||||
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
|
||||
for (InetAddress broadcastAddr : listAllBroadcastAddresses()) {
|
||||
DatagramSocket socket = new DatagramSocket();
|
||||
socket.setBroadcast(true);
|
||||
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.close();
|
||||
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
|
||||
}
|
||||
System.out.println("***********Message envoye***********");
|
||||
System.out.println("Dest Ip: " + broadcastAddr.toString());
|
||||
System.out.println("Dest port: " + String.valueOf(port));
|
||||
System.out.println("Contenu: ");
|
||||
System.out.println(broadcastMessage);
|
||||
System.out.println("************************************");
|
||||
}
|
||||
/*
|
||||
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("Dest Ip: " + broadcastAdress.toString());
|
||||
System.out.println("Dest port: " + port.toString());
|
||||
System.out.println("Contenu: ");
|
||||
System.out.println(broadcastMessage);
|
||||
System.out.println("************************************");
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>
|
||||
* Méthode permettant la reception de messages d'utilisateurs
|
||||
* à l'aide du protocole UDP
|
||||
* Methode permettant la reception de messages d'utilisateurs
|
||||
* a l'aide du protocole UDP
|
||||
* </p>
|
||||
*
|
||||
* @param app L'application de chat de l'utilisateur qui receptionne le message
|
||||
*
|
||||
*/
|
||||
public static void ecouteUDP(ChatApp app)
|
||||
{
|
||||
DatagramSocket socket = null;
|
||||
ExecutorService exec = Executors.newFixedThreadPool(1000);
|
||||
try {
|
||||
socket = new DatagramSocket(app.getMe().getPort());
|
||||
socket = new DatagramSocket(1234);
|
||||
} catch (SocketException e1) {
|
||||
e1.printStackTrace();
|
||||
}
|
||||
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)
|
||||
{
|
||||
DatagramPacket data = new DatagramPacket(buffer,buffer.length);
|
||||
|
|
@ -107,29 +109,39 @@ public class UDPEchange {
|
|||
} catch (IOException e) {
|
||||
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!");
|
||||
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();
|
||||
byte[]buffer = broadcastMessage.getBytes();
|
||||
//DatagramPacket packet = new DatagramPacket( buffer, buffer.length, InetAddress.getLoopbackAddress(), port );
|
||||
DatagramPacket packet = new DatagramPacket( buffer, buffer.length, broadcastAdress, port );
|
||||
byte[]buffer = Message.getBytes();
|
||||
DatagramPacket packet = new DatagramPacket( buffer, buffer.length, Adress, 1234 );
|
||||
socket.send(packet);
|
||||
socket.close();
|
||||
System.out.println("***********Message envoye***********");
|
||||
System.out.println("Dest Ip: " + broadcastAdress.toString());
|
||||
System.out.println("Dest port: " + port.toString());
|
||||
System.out.println("Dest Ip: " + Adress.toString());
|
||||
System.out.println("Dest port: " + String.valueOf(1234));
|
||||
System.out.println("Contenu: ");
|
||||
System.out.println(broadcastMessage);
|
||||
System.out.println(Message);
|
||||
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 {
|
||||
List<InetAddress> broadcastList = new ArrayList<>();
|
||||
Enumeration<NetworkInterface> interfaces
|
||||
|
|
@ -155,8 +167,8 @@ public class UDPEchange {
|
|||
|
||||
/**
|
||||
* <p>
|
||||
* Classe implémentant l'interface Runnable.
|
||||
* Contient les traitements à executer dans un thread lancer par des méthodes de la class UDPEchange
|
||||
* Classe implementant l'interface Runnable.
|
||||
* Contient les traitements a executer dans un thread lancer par des methodes de la class UDPEchange
|
||||
* </p>
|
||||
*/
|
||||
class RunnerUDP implements Runnable {
|
||||
|
|
@ -170,7 +182,7 @@ class RunnerUDP implements Runnable {
|
|||
|
||||
/**
|
||||
* <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
|
||||
* </p>
|
||||
*
|
||||
|
|
@ -184,10 +196,10 @@ class RunnerUDP implements Runnable {
|
|||
System.out.println("**********************************");
|
||||
String Type = received.split("\n")[0];
|
||||
|
||||
//************************************************************************************************************************
|
||||
//*************************************************************************************************************************
|
||||
//****************************************************************************************************
|
||||
//****************************************************************************************************
|
||||
//****************************************Demande de connexion****************************************
|
||||
//************************************************************************************************************************
|
||||
//****************************************************************************************************
|
||||
//****************************************
|
||||
if (Type.equals("Connexion")) { // un utilisateur vient d'arriver sur le reseau
|
||||
System.out.println("Reception d'une demande de connexion");
|
||||
|
|
@ -207,7 +219,7 @@ class RunnerUDP implements Runnable {
|
|||
reponse += app.getMe().toString();
|
||||
|
||||
try {
|
||||
UDPEchange.envoiUnicast(u.getIp(),reponse,u.getPort());
|
||||
UDPEchange.envoiUnicast(u.getIp(),reponse);
|
||||
}catch(IOException e)
|
||||
{
|
||||
System.out.println("Echec de l'envoi du message");
|
||||
|
|
@ -216,11 +228,11 @@ class RunnerUDP implements Runnable {
|
|||
( app.getActifUsers() ).afficherListeUtilisateurs();
|
||||
}
|
||||
}
|
||||
//************************************************************************************************************************
|
||||
//*************************************************************************************************************************
|
||||
//*******************************************************************************************************
|
||||
//*******************************************************************************************************
|
||||
//****************************************Reponse d'une 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****************************************
|
||||
//************************************************************************************************************************
|
||||
//************************************************************************************************************************
|
||||
//*******************************************************************************************************************
|
||||
//*******************************************************************************************************************
|
||||
|
||||
if (Type.equals("Modification Pseudo")) {
|
||||
if(( app.getActifUsers() ).verifierUnicite(received.split("\n")[2])) {
|
||||
( app.getActifUsers() ).modifierList(received.split("\n")[1],received.split("\n")[2]);
|
||||
Utilisateur Destination = Utilisateur.stringToUtilisateur(received.split("\n")[1]);
|
||||
String Message = "Bon Choix Pseudo\n" + received.split("\n")[2] ;
|
||||
System.out.println(Message);
|
||||
try {
|
||||
|
||||
//UDPEchange.envoiUnicast(Destination.getIp(),Message, Destination.getPort());
|
||||
UDPEchange.envoiUnicast(InetAddress.getLoopbackAddress(),Message, 4000);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
else {
|
||||
Utilisateur Destination = ( app.getActifUsers() ).getPseudoList(received.split("\n")[1]);
|
||||
String Message = "Mauvais Choix Pseudo\n" ;
|
||||
System.out.println(Message);
|
||||
try {
|
||||
UDPEchange.envoiUnicast(Destination.getIp(),Message, Destination.getPort());
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
( app.getActifUsers() ).afficherListeUtilisateurs();
|
||||
if (Type.equals("Demande Modification Pseudo")) {
|
||||
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] ;
|
||||
String Message = "";
|
||||
if(( app.getActifUsers() ).verifierUnicite(nouveau)) {
|
||||
Message = "Bon Choix Pseudo\n" + nouveau ;
|
||||
}
|
||||
else {
|
||||
Message = "Mauvais Choix Pseudo\n" ;
|
||||
}
|
||||
System.out.println(Message);
|
||||
try {
|
||||
UDPEchange.envoiUnicast(Source.getIp(),Message);
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
//************************************************************************************************************************
|
||||
//*************************************************************************************************************************
|
||||
//****************************************Mauvais choix d'un pseudo****************************************
|
||||
//************************************************************************************************************************
|
||||
//****************************************
|
||||
//************************************************************************************************************
|
||||
//************************************************************************************************************
|
||||
//**************************************** 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****************************************
|
||||
//*********************************************************************************************************
|
||||
//*********************************************************************************************************
|
||||
if (Type.equals("Mauvais Choix Pseudo")) {
|
||||
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")) {
|
||||
|
||||
( 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();
|
||||
// Il n'y a rien a faire ici
|
||||
}
|
||||
|
||||
//************************************************************************************************************************
|
||||
//*************************************************************************************************************************
|
||||
//*********************************************************************************************************
|
||||
//*********************************************************************************************************
|
||||
//****************************************Demande d'une deconnexion****************************************
|
||||
//************************************************************************************************************************
|
||||
//************************************************************************************************************************
|
||||
//*********************************************************************************************************
|
||||
//*********************************************************************************************************
|
||||
|
||||
if (Type.equals("Deconnexion")) {
|
||||
( app.getActifUsers() ).supprimerList(Utilisateur.stringToUtilisateur(received.split("\n")[1]));
|
||||
|
|
|
|||
Binary file not shown.
|
|
@ -1,3 +1,84 @@
|
|||
public class View{
|
||||
import java.awt.GridLayout;
|
||||
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JLabel;
|
||||
import javax.swing.JMenu;
|
||||
import javax.swing.JMenuBar;
|
||||
import javax.swing.JMenuItem;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JScrollPane;
|
||||
import javax.swing.JTable;
|
||||
|
||||
public class View extends JFrame {
|
||||
|
||||
public View() {
|
||||
//créer une instance JFrame
|
||||
super("ChatApp-AL-NM");
|
||||
|
||||
// creation d'un label qui contiendra un txt au centre
|
||||
JLabel label = new JLabel("Bonjour, Entrez un nom d'utilisateur!", JLabel.CENTER);
|
||||
|
||||
// Définissez le panel (conteneur de différents composants)
|
||||
JPanel panel = new JPanel();
|
||||
// Définir le bouton
|
||||
JButton btn1 = new JButton("Connexion");
|
||||
// Ajouter le bouton au frame
|
||||
panel.add(btn1);
|
||||
|
||||
|
||||
|
||||
/*****************************/
|
||||
//L'en-têtes du JTable
|
||||
String[] column = {"Pseudo", "port", "IP", "ID"};
|
||||
|
||||
//Les lignes du JTable
|
||||
String[][] data = {
|
||||
{"Auriane", "3000", "MBP-de-Auriane/192.168.1.43 ", "MBP-de-Auriane"},
|
||||
{"Nabil", "4000", "LAPTOP-1JO2SHBG/192.168.1.72", "LAPTOP-1JO2SHBG"}
|
||||
};
|
||||
// Créer le JTable
|
||||
JTable table = new JTable(data, column);
|
||||
JScrollPane scroll = new JScrollPane(table);
|
||||
// Ajout de la JTable
|
||||
this.add(scroll);
|
||||
|
||||
|
||||
|
||||
// Définir le menu principal
|
||||
JMenuBar menu = new JMenuBar();
|
||||
JMenu pseudo= new JMenu("Modifier Pseudo");
|
||||
JMenu clavardage = new JMenu("Clavardage");
|
||||
JMenu deconnexion = new JMenu("Deconnexion");
|
||||
// Définir le sous-menu pour Clavardage
|
||||
JMenuItem actifs = new JMenuItem("Connaitre utilisateur actifs");
|
||||
JMenuItem session = new JMenuItem("Demarrer session");
|
||||
|
||||
clavardage.add(actifs);
|
||||
clavardage.add(session);
|
||||
|
||||
menu.add(pseudo);
|
||||
menu.add(clavardage);
|
||||
menu.add(deconnexion);
|
||||
|
||||
|
||||
// Ajouter label, menu et panel au frame
|
||||
this.setLayout(new GridLayout(8, 1));
|
||||
this.add(menu);
|
||||
this.add(label);
|
||||
this.add(panel);
|
||||
|
||||
// fixer les dimensions de la fenêtre
|
||||
this.pack();
|
||||
this.setSize(500, 500);
|
||||
//sortir quand l’utilisateur ferme le frame
|
||||
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
||||
// rendre la fenêtre visible :
|
||||
this.setVisible(true);
|
||||
}
|
||||
|
||||
public static void main (String[] args) {
|
||||
JFrame frame = new View();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue