kcavaill/Projet_COO_POO
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

package messages, changement comm

Browse source
This commit is contained in:
Cavailles Kevin 2020-12-05 18:48:01 +01:00
parent 13ca8bb0c0
commit 7a4d831d56
11 changed files with 282 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
POO/src/communication/Communication.java
View file

@ -1,5 +1,6 @@
package communication;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
@ -39,35 +40,30 @@ public class Communication extends Thread{
return -1;
}
//TODO
//Combiner add et change
protected static synchronized void addUser(List<String> datas) throws UnknownHostException {
protected static int getIndexFromIP(InetAddress ip) {
for(int i=0; i < Communication.users.size() ; i++) {
if(Communication.users.get(i).getIp().equals(ip)) {
return i;
}
}
return -1;
}
protected static synchronized void addUser(String idClient, String pseudoClient, InetAddress ipClient) throws UnknownHostException {
Communication.users.add(new Utilisateur(idClient, pseudoClient, ipClient));
VueStandard.userList.addElement(pseudoClient);
}
protected static synchronized void changePseudoUser(String idClient, String pseudoClient, InetAddress ipClient) {
int index = Communication.getIndexFromID(idClient);
Communication.users.get(index).setPseudo(pseudoClient);
VueStandard.userList.set(index, pseudoClient);
}
String idClient = datas.get(0);
String pseudoClient = datas.get(1);
String clientAddress = datas.get(2);
if (!Communication.containsUserFromID(idClient)) {
Communication.users.add(new Utilisateur(idClient, pseudoClient, clientAddress));
VueStandard.userList.addElement(pseudoClient);
}
}
protected static synchronized void changePseudoUser(List<String> datas) {
String idClient = datas.get(0);
String pseudoClient = datas.get(1);
int index = Communication.getIndexFromID(idClient);
// System.out.println(index);
if(index != -1) {
Communication.users.get(index).setPseudo(pseudoClient);
VueStandard.userList.set(index, pseudoClient);
}
}
protected static synchronized void removeUser(List<String> datas) {
String idClient = datas.get(0);
int index = Communication.getIndexFromID(idClient);
//System.out.println(index);
protected static synchronized void removeUser(String idClient, String pseudoClient,InetAddress ipClient) {
int index = Communication.getIndexFromIP(ipClient);
if( index != -1) {
Communication.users.remove(index);
VueStandard.userList.remove(index);

81
POO/src/communication/CommunicationUDP.java
View file

@ -7,6 +7,8 @@ import java.util.ArrayList;
import java.util.Arrays;
import main.Utilisateur;
import messages.*;
public class CommunicationUDP extends Communication {
@ -36,64 +38,63 @@ public class CommunicationUDP extends Communication {
public void sendMessageConnecte() throws UnknownHostException, IOException {
for(int port : this.portOthers) {
this.client.sendMessageUDP_local("first_connection", port, InetAddress.getLocalHost());
try {
this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_CONNECTE), port, InetAddress.getLocalHost());
} catch (MauvaisTypeMessageException e) {/*Si ça marche pas essayer là*/}
}
}
// Send the message "add,id,pseudo" to localhost on all the ports in
// "portOthers"
// This allows the receivers' agent (portOthers) to create an entry with the
// This allows the receivers' agent (portOthers) to create or modify an entry with the
// data of this agent
public void sendMessageAdd() throws UnknownHostException, IOException {
this.sendIDPseudo_local("add");
//Typically used to notify of a name change
public void sendMessageInfoPseudo() throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf();
String pseudoSelf =self.getPseudo();
String idSelf = self.getId();
Message msout = null;
try {
msout = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, pseudoSelf, idSelf);
for(int port : this.portOthers) {
this.client.sendMessageUDP_local(msout, port, InetAddress.getLocalHost());
}
} catch (Exception e) {
e.printStackTrace();
}
}
//Same, but on only one port
//Typically used to give your current name and id to a newly arrived host
public void sendMessageInfoPseudo(int portOther) throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf();
try {
Message msout = new MessageSysteme(Message.TypeMessage.INFO_PSEUDO, self.getPseudo(), self.getId());
this.client.sendMessageUDP_local(msout, portOther, InetAddress.getLocalHost());
} catch (MauvaisTypeMessageException e) {e.printStackTrace();}
}
public void sendMessageAdd(ArrayList<Integer> portServers) throws UnknownHostException, IOException {
this.sendIDPseudo_local("add", portServers);
}
// Send the message "modify,id,pseudo" to localhost on all the ports in
// "portOthers"
// This allows the receivers' agent (portOthers) to update the entry
// corresponding to this agent
public void sendMessageModify() throws UnknownHostException, IOException {
this.sendIDPseudo_local("modify");
}
// Send the message "del,id,pseudo" to localhost on all the ports in
// "portOthers"
// This allows the receivers' agent (portOthers) to delete the entry
// corresponding to this agent
public void sendMessageDelete() throws UnknownHostException, IOException {
this.sendIDPseudo_local("del");
}
// Private function to create the message "[prefix],id,pseudo"
// and send it to localhost on all the ports in "portOthers"
private void sendIDPseudo_local(String prefixe, ArrayList<Integer> portServers) throws UnknownHostException, IOException {
Utilisateur self = Utilisateur.getSelf();
String idSelf = self.getId();
String pseudoSelf = self.getPseudo();
if (!pseudoSelf.equals("")) {
String message = prefixe + "," + idSelf + "," + pseudoSelf;
// A modifier pour créer un objet de type Message
//
//
for (int port : portServers) {
this.client.sendMessageUDP_local(message, port, InetAddress.getLocalHost());
}
for(int port : this.portOthers) {
try {
this.client.sendMessageUDP_local(new MessageSysteme(Message.TypeMessage.JE_SUIS_DECONNECTE), port, InetAddress.getLocalHost());
} catch (MauvaisTypeMessageException e) {/*Si ça marche pas essayer là*/}
}
}
private void sendIDPseudo_local(String prefixe) throws UnknownHostException, IOException {
this.sendIDPseudo_local(prefixe, this.portOthers);
}
//Pas encore adapte message
// private void sendIDPseudo_broadcast(String prefixe) throws UnknownHostException, IOException {
// Utilisateur self = Utilisateur.getSelf();
// String idSelf = self.getId();

16
POO/src/communication/UDPClient.java
View file

@ -8,6 +8,8 @@ import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import messages.*;
public class UDPClient {
private DatagramSocket sockUDP;
@ -22,19 +24,17 @@ public class UDPClient {
}
//Send a string message to the specified port on localhost
protected void sendMessageUDP_local(String message, int port, InetAddress clientAddress) throws IOException {
//A modifier, faire passer un type Message en paramètre
//puis écrire les instructions pour envoyer un Message à traver la socket
DatagramPacket outpacket = new DatagramPacket(message.getBytes(), message.length(), clientAddress, port);
//Send a message casted as string to the specified port on localhost
protected void sendMessageUDP_local(Message message, int port, InetAddress clientAddress) throws IOException {
String messageString=message.toString();
DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), clientAddress, port);
this.sockUDP.send(outpacket);
}
// protected void sendMessageUDP_broadcast(String message, int port) throws IOException{
// DatagramPacket outpacket = new DatagramPacket(message.getBytes(), message.length(), this.broadcast, port);
// String messageString=message.toString();
// DatagramPacket outpacket = new DatagramPacket(messageString.getBytes(), messageString.length(), this.broadcast, port);
// this.sockUDP.send(outpacket);
// }

60
POO/src/communication/UDPServer.java
View file

@ -7,6 +7,8 @@ import java.net.SocketException;
import java.util.ArrayList;
import java.util.Arrays;
import messages.*;
public class UDPServer extends Thread {
@ -26,52 +28,44 @@ public class UDPServer extends Thread {
while (true) {
try {
DatagramPacket inPacket = new DatagramPacket(buffer, buffer.length);
this.sockUDP.receive(inPacket);
String msg = new String(inPacket.getData(), 0, inPacket.getLength());
String msgString = new String(inPacket.getData(), 0, inPacket.getLength());
Message msg = Message.stringToMessage(msgString);
if (msg.equals("first_connection")) {
switch(msg.getTypeMessage()) {
case JE_SUIS_CONNECTE :
//System.out.println("first co");
ArrayList<Integer> portClient = new ArrayList<Integer>();
portClient.add(inPacket.getPort()+1);
this.commUDP.sendMessageAdd(portClient);
int portClient = inPacket.getPort();
int portServer = portClient+1;
} else if (msg.contains("add,")) {
//System.out.println("add");
ArrayList<String> datas = this.getDatas(inPacket);
Communication.addUser(datas);
this.commUDP.sendMessageInfoPseudo(portServer);
break;
} else if (msg.contains("modify,")) {
ArrayList<String> datas = this.getDatas(inPacket);
Communication.changePseudoUser(datas);
case INFO_PSEUDO :
} else if (msg.contains("del,")) {
ArrayList<String> datas = this.getDatas(inPacket);
Communication.removeUser(datas);
if (Communication.containsUserFromID(((MessageSysteme) msg).getId())) {
Communication.changePseudoUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(), inPacket.getAddress());
}
else {
Communication.addUser(((MessageSysteme) msg).getId(), ((MessageSysteme) msg).getPseudo(), inPacket.getAddress());
System.out.println(((MessageSysteme) msg).getId()+", "+((MessageSysteme) msg).getPseudo());
}
break;
case JE_SUIS_DECONNECTE :
Communication.removeUser( ((MessageSysteme) msg).getId() , ((MessageSysteme) msg).getPseudo(), inPacket.getAddress() );
break;
default : //Others types of messages are ignored because they are supposed to be transmitted by TCP and not UDP
}
} catch (IOException e) {
System.out.println("receive exception");
}
}
}
protected ArrayList<String> getDatas(DatagramPacket inPacket) {
//Message
//
String msg = new String(inPacket.getData(), 0, inPacket.getLength());
String tmp[] = msg.split(",");
ArrayList<String> datas = new ArrayList<String>(Arrays.asList(tmp));
datas.remove(0);
datas.add(inPacket.getAddress().toString());
return datas;
}
}

6
POO/src/main/ControleurStandard.java
View file

@ -29,7 +29,7 @@ public class ControleurStandard implements ActionListener, ListSelectionListener
this.vue = vue;
this.commUDP = new CommunicationUDP(portClient,portServer, portsOther);
this.commUDP.sendMessageConnecte();
this.commUDP.sendMessageAdd();
this.commUDP.sendMessageInfoPseudo();
this.etatModif = EtatModif.TERMINE;
}
@ -60,7 +60,7 @@ public class ControleurStandard implements ActionListener, ListSelectionListener
Utilisateur.getSelf().setPseudo(this.vue.getDisplayedPseudo());
try {
this.commUDP.sendMessageModify();
this.commUDP.sendMessageInfoPseudo();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
@ -99,7 +99,7 @@ public class ControleurStandard implements ActionListener, ListSelectionListener
try {
Utilisateur.getSelf().setPseudo(this.vue.getDisplayedPseudo());
this.commUDP.sendMessageConnecte();
this.commUDP.sendMessageAdd();
this.commUDP.sendMessageInfoPseudo();
this.vue.toggleEnableButtonConnexion();
this.vue.toggleEnableButtonDeconnexion();

9
POO/src/main/Utilisateur.java
View file

@ -15,11 +15,11 @@ public class Utilisateur implements Serializable{
private static Utilisateur self;
public Utilisateur(String id, String pseudo, String host) throws UnknownHostException {
public Utilisateur(String id, String pseudo, InetAddress ip) throws UnknownHostException {
this.id = id;
this.pseudo = pseudo;
this.ip = InetAddress.getLocalHost();
//System.out.println(InetAddress.getLocalHost());
this.ip = ip;
System.out.println(InetAddress.getLocalHost());
}
@ -41,9 +41,8 @@ public class Utilisateur implements Serializable{
public static void setSelf(String id, String pseudo,String host) throws UnknownHostException {
if(Utilisateur.self == null) {
Utilisateur.self = new Utilisateur(id, pseudo, host);
Utilisateur.self = new Utilisateur(id, pseudo, InetAddress.getByName(host));
}
}
public static Utilisateur getSelf() {

8
POO/src/messages/MauvaisTypeMessageException.java Normal file
View file

@ -0,0 +1,8 @@
package messages;
public class MauvaisTypeMessageException extends Exception {
private static final long serialVersionUID = 1L;
}

69
POO/src/messages/Message.java Normal file
View file

@ -0,0 +1,69 @@
package messages;
import java.io.Serializable;
import java.lang.instrument.Instrumentation;
import java.util.Arrays;
import messages.Message.TypeMessage;
public abstract class Message implements Serializable {
public enum TypeMessage {JE_SUIS_CONNECTE, JE_SUIS_DECONNECTE, INFO_PSEUDO, TEXTE, IMAGE, FICHIER, MESSAGE_NUL}
protected TypeMessage type;
private static final long serialVersionUID = 1L;
private static Instrumentation inst;
public TypeMessage getTypeMessage() {
return this.type;
}
protected abstract String attributsToString();
public String toString() {
return this.type+"###"+this.attributsToString();
}
public static Message stringToMessage(String messageString) {
try {
String[] parts = messageString.split("###");
switch (parts[0]) {
case "JE_SUIS_CONNECTE" :
return new MessageSysteme(TypeMessage.JE_SUIS_CONNECTE);
case "JE_SUIS_DECONNECTE" :
return new MessageSysteme(TypeMessage.JE_SUIS_DECONNECTE);
case "INFO_PSEUDO" :
return new MessageSysteme(TypeMessage.INFO_PSEUDO, parts[1], parts[2]);
case "TEXTE" :
return new MessageTexte(TypeMessage.TEXTE, parts[1]);
case "IMAGE" :
return new MessageFichier(TypeMessage.IMAGE, parts[1], parts[2]);
case "FICHIER" :
return new MessageFichier(TypeMessage.FICHIER, parts[1], parts[2]);
}
} catch (MauvaisTypeMessageException e) {}
return null;
}
//tests ici
public static void main(String[] args) throws MauvaisTypeMessageException {
Message m1 = new MessageSysteme(TypeMessage.JE_SUIS_CONNECTE);
Message m2 = new MessageSysteme(TypeMessage.JE_SUIS_DECONNECTE);
Message m3 = new MessageSysteme(TypeMessage.INFO_PSEUDO, "pseudo156434518", "id236");
Message m4 = new MessageTexte(TypeMessage.TEXTE, "blablabla");
Message m5 = new MessageFichier(TypeMessage.FICHIER, "truc", ".pdf");
System.out.println(Message.stringToMessage(m1.toString()));
System.out.println(Message.stringToMessage(m2.toString()));
System.out.println(Message.stringToMessage(m3.toString()));
System.out.println(Message.stringToMessage(m4.toString()));
System.out.println(Message.stringToMessage(m5.toString()));
}
}

33
POO/src/messages/MessageFichier.java Normal file
View file

@ -0,0 +1,33 @@
package messages;
import messages.Message.TypeMessage;
public class MessageFichier extends Message {
private static final long serialVersionUID = 1L;
private String contenu;
private String extension;
public MessageFichier(TypeMessage type, String contenu, String extension) throws MauvaisTypeMessageException{
if ((type==TypeMessage.IMAGE)||(type==TypeMessage.FICHIER)) {
this.type=type;
this.contenu=contenu;
this.extension=extension;
}
else throw new MauvaisTypeMessageException();
}
public String getContenu() {
return this.contenu;
}
public String getExtension() {
return this.extension;
}
@Override
protected String attributsToString() {
return this.contenu+"###"+this.extension;
}
}

39
POO/src/messages/MessageSysteme.java Normal file
View file

@ -0,0 +1,39 @@
package messages;
public class MessageSysteme extends Message {
private static final long serialVersionUID = 1L;
private String pseudo;
private String id;
public MessageSysteme(TypeMessage type) throws MauvaisTypeMessageException{
if ((type==TypeMessage.JE_SUIS_CONNECTE)||(type==TypeMessage.JE_SUIS_DECONNECTE)||(type==TypeMessage.MESSAGE_NUL)) {
this.type=type;
this.pseudo="";
this.id="";
}
else throw new MauvaisTypeMessageException();
}
public MessageSysteme(TypeMessage type, String pseudo, String id) throws MauvaisTypeMessageException {
if (type==TypeMessage.INFO_PSEUDO) {
this.type=type;
this.pseudo=pseudo;
this.id=id;
}
else throw new MauvaisTypeMessageException();
}
public String getPseudo() {
return this.pseudo;
}
public String getId() {
return this.id;
}
@Override
protected String attributsToString() {
return this.pseudo+"###"+this.id;
}
}

27
POO/src/messages/MessageTexte.java Normal file
View file

@ -0,0 +1,27 @@
package messages;
import messages.Message.TypeMessage;
public class MessageTexte extends Message {
private static final long serialVersionUID = 1L;
private String contenu;
public MessageTexte(TypeMessage type, String contenu) throws MauvaisTypeMessageException{
if (type==TypeMessage.TEXTE) {
this.type=type;
this.contenu=contenu;
}
else throw new MauvaisTypeMessageException();
}
public String getContenu() {
return this.contenu;
}
@Override
protected String attributsToString() {
return this.contenu;
}
}