Start refactoring ClientConnectionHandler.java

ERROR UnsupportedOperationException in ClientMessageList

client/src/main/java/ch/zhaw/pm2/multichat/client/ChatWindowController.java

@@ -4,6 +4,9 @@ import ch.zhaw.pm2.multichat.client.ClientConnectionHandler.State;
 import ch.zhaw.pm2.multichat.protocol.ChatProtocolException;
 import ch.zhaw.pm2.multichat.protocol.NetworkHandler;
 import javafx.application.Platform;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.collections.ListChangeListener;
 import javafx.event.EventHandler;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
@@ -19,7 +22,6 @@ import java.util.regex.Pattern;
 import static ch.zhaw.pm2.multichat.client.ClientConnectionHandler.State.*;
 
 public class ChatWindowController {
-    private final Pattern messagePattern = Pattern.compile( "^(?:@(\\w*))?\\s*(.*)$" );
     private ClientConnectionHandler connectionHandler;
     private ClientMessageList messages;
 
@@ -40,8 +42,14 @@ public class ChatWindowController {
     public void initialize() {
         serverAddressField.setText(NetworkHandler.DEFAULT_ADDRESS.getCanonicalHostName());
         serverPortField.setText(String.valueOf(NetworkHandler.DEFAULT_PORT));
-        stateChanged(NEW);
-        messages = new ClientMessageList(this);
+        this.messages = new ClientMessageList();
+
+        messages.getChangedProperty().addListener(new ChangeListener<Boolean>() {
+            @Override
+            public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
+                setMessageField(messages.getMessages());
+            }
+        });
     }
 
     private void applicationClose() {
@@ -50,7 +58,7 @@ public class ChatWindowController {
 
     @FXML
     private void toggleConnection () {
-        if (connectionHandler == null || connectionHandler.getState() != CONNECTED) {
+        if (connectionHandler == null || connectionHandler.getStateObjectProperty().get() != CONNECTED) {
             connect();
         } else {
             disconnect();
@@ -59,63 +67,58 @@ public class ChatWindowController {
 
     private void connect() {
         try {
-            messages = new ClientMessageList(this); // clear message list
+            messages.clear(); // clear message list
             startConnectionHandler();
             connectionHandler.connect();
         } catch(ChatProtocolException | IOException e) {
-            writeError(e.getMessage());
+            messages.addMessage(null,null, e.getMessage(), Message.MessageType.ERROR);
         }
     }
 
     private void disconnect() {
         if (connectionHandler == null) {
-            writeError("No connection handler");
+            messages.addMessage(null,null,"No connection handler", Message.MessageType.ERROR);
             return;
         }
         try {
             connectionHandler.disconnect();
         } catch (ChatProtocolException e) {
-            writeError(e.getMessage());
+            messages.addMessage(null,null, e.getMessage(), Message.MessageType.ERROR);
         }
     }
 
     @FXML
     private void message() {
-        if (connectionHandler == null) {
-            writeError("No connection handler");
-            return;
-        }
         String messageString = messageField.getText().strip();
-        messageField.clear();
-        Matcher matcher = messagePattern.matcher(messageString);
-        if (matcher.find()) {
-            String receiver = matcher.group(1);
-            String message = matcher.group(2);
-            if (receiver == null || receiver.isBlank()) receiver = ClientConnectionHandler.USER_ALL;
-            try {
-                connectionHandler.message(receiver, message);
-            } catch (ChatProtocolException e) {
-                writeError(e.getMessage());
+        try {
+            if (connectionHandler == null) {
+                messages.addMessage(null,null,"No connection handler", Message.MessageType.ERROR);
+            } else if (!connectionHandler.message(messageString)) {
+                messages.addMessage(null,null,"Not a valid message format.", Message.MessageType.ERROR);
+            } else {
+                messageField.clear();
             }
-        } else {
-            writeError("Not a valid message format.");
+        } catch (ChatProtocolException e) {
+            messages.addMessage(null,null, e.getMessage(), Message.MessageType.ERROR);
         }
     }
 
+    //TODO: TEST
     @FXML
     private void applyFilter( ) {
-    	this.redrawMessageList();
+        messages.getFilteredMessages(filterValue.getText().strip());
     }
 
     private void startConnectionHandler() throws IOException {
         String userName = userNameField.getText();
         String serverAddress = serverAddressField.getText();
         int serverPort = Integer.parseInt(serverPortField.getText());
-        connectionHandler = new ClientConnectionHandler(
-            NetworkHandler.openConnection(serverAddress, serverPort), userName,
-            this);
+        connectionHandler = new ClientConnectionHandler(messages,serverAddress,serverPort,userName);
         new Thread(connectionHandler).start();
 
+        //register changelistener
+        startChangeListener();
+
         // register window close handler
         rootPane.getScene().getWindow().addEventHandler(WindowEvent.WINDOW_CLOSE_REQUEST, windowCloseHandler);
     }
@@ -142,6 +145,49 @@ public class ChatWindowController {
         }
     }
 
+    private void startChangeListener() {
+        //Listener for State
+        connectionHandler.getStateObjectProperty().addListener(new ChangeListener<State>() {
+            @Override
+            public void changed(ObservableValue<? extends State> observable, State oldValue, State newValue) {
+                stateChanged(newValue);
+            }
+        });
+
+        //Listener for Username
+        connectionHandler.getUserNameProperty().addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
+                setUserName(newValue);
+            }
+        });
+
+        //Listener for Address
+        connectionHandler.getServerAddressProperty().addListener(new ChangeListener<String>() {
+            @Override
+            public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {
+                setServerAddress(newValue);
+            }
+        });
+
+        //Listener for Port
+        connectionHandler.getServerPortProperty().addListener(new ChangeListener<Number>() {
+            @Override
+            public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
+                setServerPort(newValue.intValue());
+            }
+        });
+    }
+
+    public void setMessageField(String message) {
+        Platform.runLater(new Runnable() {
+            @Override
+            public void run() {
+                messageField.setText(message);
+            }
+        });
+    }
+
     public void setUserName(String userName) {
         Platform.runLater(new Runnable() {
             @Override
@@ -169,43 +215,12 @@ public class ChatWindowController {
         });
     }
 
-    public void addMessage(String sender, String receiver, String message) {
-        messages.addMessage(ClientMessageList.MessageType.MESSAGE, sender, receiver, message);
-        this.redrawMessageList();
-    }
-
-    public void addInfo(String message) {
-        messages.addMessage(ClientMessageList.MessageType.INFO, null, null, message);
-        this.redrawMessageList();
-    }
-
-    public void addError(String message) {
-        messages.addMessage(ClientMessageList.MessageType.ERROR, null, null, message);
-        this.redrawMessageList();
-    }
-
-    public void clearMessageArea() {
-        this.messageArea.clear();
-    }
-
-
+    //TODO: MAKE ChangeListener
     private void redrawMessageList() {
-        Platform.runLater(() -> messages.writeFilteredMessages(filterValue.getText().strip()));
+        this.messageArea.clear();
+        Platform.runLater(() -> this.messageArea.setText(messages.getFilteredMessages(filterValue.getText().strip())));
     }
 
-    public void writeError(String message) {
-        this.messageArea.appendText(String.format("[ERROR] %s\n", message));
-    }
-
-    public void writeInfo(String message) {
-        this.messageArea.appendText(String.format("[INFO] %s\n", message));
-    }
-
-    public void writeMessage(String sender, String reciever, String message) {
-        this.messageArea.appendText(String.format("[%s -> %s] %s\n", sender, reciever, message));
-    }
-
-
     class WindowCloseHandler implements EventHandler<WindowEvent> {
         public void handle(WindowEvent event) {
             applicationClose();
@@ -213,7 +228,4 @@ public class ChatWindowController {
 
     }
 
-
-
-
 }

client/src/main/java/ch/zhaw/pm2/multichat/client/ClientConnectionHandler.java

@@ -2,17 +2,23 @@ package ch.zhaw.pm2.multichat.client;
 
 import ch.zhaw.pm2.multichat.protocol.ChatProtocolException;
 import ch.zhaw.pm2.multichat.protocol.NetworkHandler;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.SocketException;
 import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import static ch.zhaw.pm2.multichat.client.ClientConnectionHandler.State.*;
+import static ch.zhaw.pm2.multichat.client.Message.MessageType.*;
 
 public class ClientConnectionHandler implements Runnable {
-    private final NetworkHandler.NetworkConnection<String> connection;
-    private final ChatWindowController controller;
+    private NetworkHandler.NetworkConnection<String> connection;
 
     // Data types used for the Chat Protocol
     private static final String DATA_TYPE_CONNECT = "CONNECT";
@@ -24,28 +30,44 @@ public class ClientConnectionHandler implements Runnable {
     public static final String USER_NONE = "";
     public static final String USER_ALL = "*";
 
-    private String userName = USER_NONE;
-    private State state = NEW;
+    private SimpleStringProperty userName;
+    private SimpleIntegerProperty serverPort;
+    private SimpleStringProperty serverAddress;
+    private ObjectProperty<State> stateObjectProperty;
+    private ClientMessageList messageList;
+    private final Pattern messagePattern = Pattern.compile( "^(?:@(\\w*))?\\s*(.*)$" );
 
     enum State {
         NEW, CONFIRM_CONNECT, CONNECTED, CONFIRM_DISCONNECT, DISCONNECTED;
     }
 
-    public ClientConnectionHandler(NetworkHandler.NetworkConnection<String> connection,
-                                   String userName,
-                                   ChatWindowController controller)  {
-        this.connection = connection;
-        this.userName = (userName == null || userName.isBlank())? USER_NONE : userName;
-        this.controller = controller;
+    public ClientConnectionHandler(ClientMessageList messageList,String serverAddress,int serverPort,String userName) throws IOException {
+        this.stateObjectProperty = new SimpleObjectProperty<>(NEW);
+        this.userName = new SimpleStringProperty((userName == null || userName.isBlank())? USER_NONE : userName);
+        this.serverPort = new SimpleIntegerProperty();
+        this.serverAddress = new SimpleStringProperty();
+        this.messageList = messageList;
+        this.connection = NetworkHandler.openConnection(serverAddress,serverPort);
     }
 
-    public State getState() {
-        return this.state;
+    public ObjectProperty<State> getStateObjectProperty() {
+        return stateObjectProperty;
+    }
+
+    public SimpleStringProperty getUserNameProperty() {
+        return userName;
+    }
+
+    public SimpleStringProperty getServerAddressProperty() {
+        return serverAddress;
+    }
+
+    public SimpleIntegerProperty getServerPortProperty() {
+        return serverPort;
     }
 
     public void setState (State newState) {
-        this.state = newState;
-        controller.stateChanged(newState);
+        this.stateObjectProperty.set(newState);
     }
 
     public void run () {
@@ -89,6 +111,7 @@ public class ClientConnectionHandler implements Runnable {
         System.out.println("Closed Connection Handler to Server");
     }
 
+
     private void processData(String data) {
         try {
             // parse data content
@@ -119,45 +142,44 @@ public class ClientConnectionHandler implements Runnable {
             if (type.equals(DATA_TYPE_CONNECT)) {
                 System.err.println("Illegal connect request from server");
             } else if (type.equals(DATA_TYPE_CONFIRM)) {
-                if (state == CONFIRM_CONNECT) {
-                    this.userName = reciever;
-                    controller.setUserName(userName);
-                    controller.setServerPort(connection.getRemotePort());
-                    controller.setServerAddress(connection.getRemoteHost());
-                    controller.addInfo(payload);
+                if (stateObjectProperty.get() == CONFIRM_CONNECT) {
+                    this.userName.set(reciever);
+                    this.serverAddress.set(connection.getRemoteHost());
+                    this.serverPort.set(connection.getRemotePort());
+                    messageList.addMessage(sender,reciever,payload,INFO);
                     System.out.println("CONFIRM: " + payload);
                     this.setState(CONNECTED);
-                } else if (state == CONFIRM_DISCONNECT) {
-                    controller.addInfo(payload);
+                } else if (stateObjectProperty.get() == CONFIRM_DISCONNECT) {
+                    messageList.addMessage(sender,reciever,payload,INFO);
                     System.out.println("CONFIRM: " + payload);
                     this.setState(DISCONNECTED);
                 } else {
                     System.err.println("Got unexpected confirm message: " + payload);
                 }
             } else if (type.equals(DATA_TYPE_DISCONNECT)) {
-                if (state == DISCONNECTED) {
+                if (stateObjectProperty.get() == DISCONNECTED) {
                     System.out.println("DISCONNECT: Already in disconnected: " + payload);
                     return;
                 }
-                controller.addInfo(payload);
+                messageList.addMessage(sender,reciever,payload,INFO);
                 System.out.println("DISCONNECT: " + payload);
                 this.setState(DISCONNECTED);
             } else if (type.equals(DATA_TYPE_MESSAGE)) {
-                if (state != CONNECTED) {
-                    System.out.println("MESSAGE: Illegal state " + state + " for message: " + payload);
+                if (stateObjectProperty.get() != CONNECTED) {
+                    System.out.println("MESSAGE: Illegal state " + stateObjectProperty.get() + " for message: " + payload);
                     return;
                 }
-                controller.addMessage(sender, reciever, payload);
+                messageList.addMessage(sender,reciever,payload,MESSAGE);
                 System.out.println("MESSAGE: From " + sender + " to " + reciever + ": "+  payload);
             } else if (type.equals(DATA_TYPE_ERROR)) {
-                controller.addError(payload);
+                messageList.addMessage(sender,reciever,payload,ERROR);
                 System.out.println("ERROR: " + payload);
             } else {
                 System.out.println("Unknown data type received: " + type);
             }
         } catch (ChatProtocolException e) {
             System.err.println("Error while processing data: " + e.getMessage());
-            sendData(USER_NONE, userName, DATA_TYPE_ERROR, e.getMessage());
+            sendData(USER_NONE, userName.get(), DATA_TYPE_ERROR, e.getMessage());
         }
     }
 
@@ -183,20 +205,33 @@ public class ClientConnectionHandler implements Runnable {
     }
 
     public void connect() throws ChatProtocolException {
-        if (state != NEW) throw new ChatProtocolException("Illegal state for connect: " + state);
-        this.sendData(userName, USER_NONE, DATA_TYPE_CONNECT,null);
+        if (stateObjectProperty.get() != NEW) throw new ChatProtocolException("Illegal state for connect: " + stateObjectProperty.get());
+        this.sendData(userName.get(), USER_NONE, DATA_TYPE_CONNECT,null);
         this.setState(CONFIRM_CONNECT);
     }
 
     public void disconnect() throws ChatProtocolException {
-        if (state != NEW && state != CONNECTED) throw new ChatProtocolException("Illegal state for disconnect: " + state);
-        this.sendData(userName, USER_NONE, DATA_TYPE_DISCONNECT,null);
+        if (stateObjectProperty.get() != NEW && stateObjectProperty.get() != CONNECTED) throw new ChatProtocolException("Illegal state for disconnect: " + stateObjectProperty.get());
+        this.sendData(userName.get(), USER_NONE, DATA_TYPE_DISCONNECT,null);
         this.setState(CONFIRM_DISCONNECT);
     }
 
-    public void message(String receiver, String message) throws ChatProtocolException {
-        if (state != CONNECTED) throw new ChatProtocolException("Illegal state for message: " + state);
-        this.sendData(userName, receiver, DATA_TYPE_MESSAGE,message);
+    public boolean message(String messageString) throws ChatProtocolException {
+        if (stateObjectProperty.get() != CONNECTED) throw new ChatProtocolException("Illegal state for message: " + stateObjectProperty.get());
+
+        Matcher matcher = messagePattern.matcher(messageString);
+        if (matcher.find()) {
+            String receiver = matcher.group(1);
+            String message = matcher.group(2);
+            if(message.length() < 1){
+                return false;
+            }
+            if (receiver == null || receiver.isBlank()) receiver = ClientConnectionHandler.USER_ALL;
+            this.sendData(userName.get(), receiver, DATA_TYPE_MESSAGE,message);
+            return true;
+        } else {
+            return false;
+        }
     }
 
 }

client/src/main/java/ch/zhaw/pm2/multichat/client/ClientMessageList.java

@@ -1,51 +1,68 @@
 package ch.zhaw.pm2.multichat.client;
 
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleListProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
+
+import static ch.zhaw.pm2.multichat.client.ClientConnectionHandler.USER_NONE;
 
 public class ClientMessageList {
-    private final List<MessageType> typeList = new ArrayList<>();
-	private final List<String> senderList = new ArrayList<>();
-	private final List<String> receiverList = new ArrayList<>();
-	private final List<String> messageList = new ArrayList<>();
-	private final ChatWindowController gui;
+    private List<Message> messages;
+    private SimpleBooleanProperty changed;
 
-	public ClientMessageList(ChatWindowController gui) {
-		this.gui = gui;
-	}
-
-    public void addMessage(MessageType type, String sender, String receiver, String message) {
-	    typeList.add(type);
-    	senderList.add(sender);
-    	receiverList.add(receiver);
-    	messageList.add(message);
+    public ClientMessageList() {
+        messages = new ArrayList<>();
+        changed = new SimpleBooleanProperty(true);
     }
 
-	public void writeFilteredMessages(String filter) {
+    public SimpleBooleanProperty getChangedProperty() {
+        return changed;
+    }
+
+    public void addMessage(String sender, String receiver, String message, Message.MessageType type) {
+        if(sender == null) {
+            sender = USER_NONE;
+        }
+        messages.add(new Message(type, sender, receiver, message));
+        changed.set(!changed.get());
+    }
+
+	public String getFilteredMessages(String filter) {
+        StringBuilder result = new StringBuilder();
 		boolean showAll = filter == null || filter.isBlank();
-		gui.clearMessageArea();
-		for(int i=0; i<senderList.size(); i++) {
-		    String sender = Objects.requireNonNullElse(senderList.get(i),"");
-		    String receiver = Objects.requireNonNullElse(receiverList.get(i),"");
-		    String message = Objects.requireNonNull(messageList.get(i), "");
-			if(showAll ||
-					sender.contains(filter) ||
-					receiver.contains(filter) ||
-					message.contains(filter))
+		for(Message message : messages) {
+			if(showAll || message.matchesFilter(filter))
 			{
-			    switch (typeList.get(i)) {
-                    case MESSAGE: gui.writeMessage(senderList.get(i), receiverList.get(i), messageList.get(i)); break;
-                    case ERROR: gui.writeError(messageList.get(i)); break;
-                    case INFO: gui.writeInfo(messageList.get(i)); break;
-                    default: gui.writeError("Unexpected message type: " + typeList.get(i));
+                switch (message.getType()) {
+                    case MESSAGE -> result.append(String.format("[%s -> %s] %s\n", message.getSender(), message.getReceiver(), message.getText()));
+                    case ERROR -> result.append(String.format("[ERROR] %s\n", message.getText()));
+                    case INFO -> result.append(String.format("[INFO] %s\n", message.getText()));
+                    default -> result.append(String.format("[ERROR] %s\n", "Unexpected message type: " + message.getType()));
                 }
 			}
 		}
+        return result.toString();
 	}
 
-    public enum MessageType {
-        INFO, MESSAGE, ERROR;
+	public String getMessages() {
+        StringBuilder result = new StringBuilder();
+        for(Message message : messages) {
+            switch (message.getType()) {
+                case MESSAGE -> result.append(String.format("[%s -> %s] %s\n", message.getSender(), message.getReceiver(), message.getText()));
+                case ERROR -> result.append(String.format("[ERROR] %s\n", message.getText()));
+                case INFO -> result.append(String.format("[INFO] %s\n", message.getText()));
+                default -> result.append(String.format("[ERROR] %s\n", "Unexpected message type: " + message.getType()));
+            }
+        }
+        return result.toString();
+    }
+
+    public void clear() {
+        messages = new SimpleListProperty<>();
     }
 
 }

client/src/main/java/ch/zhaw/pm2/multichat/client/ClientUI.java

@@ -7,6 +7,7 @@ import javafx.scene.layout.Pane;
 import javafx.stage.Stage;
 
 public class ClientUI extends Application {
+    private ClientMessageList clientMessageList = new ClientMessageList();
 
     @Override
     public void start(Stage primaryStage) {
@@ -16,7 +17,9 @@ public class ClientUI extends Application {
     private void chatWindow(Stage primaryStage) {
         try {
             FXMLLoader loader = new FXMLLoader(getClass().getResource("ChatWindow.fxml"));
+
             Pane rootPane = loader.load();
+
             // fill in scene and stage setup
             Scene scene = new Scene(rootPane);
             //scene.getStylesheets().add(getClass().getResource("application.css").toExternalForm());

client/src/main/java/ch/zhaw/pm2/multichat/client/Message.java

@@ -0,0 +1,71 @@
+package ch.zhaw.pm2.multichat.client;
+
+/**
+A Message object represents one Message of a client. Can be stored in ClientMessageList.
+ */
+public class Message {
+    private MessageType type;
+    private String sender;
+    private String receiver;
+    private String text;
+
+    /**
+     * Constructor of Message. Needs all Information about a Message to save them.
+     * @param type Message (if it's a message typed by a user), Error or Information (if it is generated automatically, in this case sender and reciever will be null)
+     * @param sender The User who has sent the message.
+     * @param receiver The User who should recieve the message.
+     * @param text The Text of the message.
+     */
+    public Message(MessageType type, String sender, String receiver, String text) {
+        this.type = type;
+        this.sender = sender;
+        this.receiver = receiver;
+        this.text = text;
+    }
+
+    /**
+     * Checks if the Filter String is contained in one of the datafields sender, receiver or text
+     * @param filter The Filter String
+     * @return true if it the Filter String is contained in a datafield.
+     */
+    public boolean matchesFilter(String filter){
+        return (sender != null && sender.contains(filter)) ||
+            (receiver != null && receiver.contains(filter)) ||
+            (text != null && text.contains(filter));
+    }
+
+    /**
+     * @return The type of the message.
+     */
+    public MessageType getType() {
+        return type;
+    }
+
+    /**
+     * @return The User who has sent the Message.
+     */
+    public String getSender() {
+        return sender;
+    }
+
+    /**
+     * @return The Reciever who recieves the Message.
+     */
+    public String getReceiver() {
+        return receiver;
+    }
+
+    /**
+     * @return The Text of the Message.
+     */
+    public String getText() {
+        return text;
+    }
+
+    /**
+     * Enummeration of Message Types.
+     */
+    public enum MessageType {
+        INFO, MESSAGE, ERROR;
+    }
+}