fixed Method Initializing. Setting Datafields serverAddress and serverPort.

#24

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

@@ -1,9 +1,9 @@
 package ch.zhaw.pm2.multichat.client;
 
-import ch.zhaw.pm2.multichat.protocol.ConnectionHandler;
 import ch.zhaw.pm2.multichat.protocol.ConnectionHandler.State;
 import ch.zhaw.pm2.multichat.protocol.ChatProtocolException;
-import ch.zhaw.pm2.multichat.protocol.Message;
+import ch.zhaw.pm2.multichat.protocol.ConnectionHandler;
+import ch.zhaw.pm2.multichat.protocol.NetworkHandler;
 import javafx.application.Platform;
 import javafx.beans.value.ChangeListener;
 import javafx.beans.value.ObservableValue;
@@ -19,71 +19,44 @@ import java.io.IOException;
 
 import static ch.zhaw.pm2.multichat.protocol.ConnectionHandler.State.*;
 
-/**
- * Class Representing the Controller Element of the Window, also Contains the Elements that contacts the View Elements via
- * Listeners and Observable Objects.
- * To Contact the Model Elements needed it also holds references to message and the Connectionhandler.
- */
 public class ChatWindowController {
     private ClientConnectionHandler connectionHandler;
     private ClientMessageList messages;
+
     private final WindowCloseHandler windowCloseHandler = new WindowCloseHandler();
 
-    @FXML
-    private Pane rootPane;
-    @FXML
-    private TextField serverAddressField;
-    @FXML
-    private TextField serverPortField;
-    @FXML
-    private TextField userNameField;
-    @FXML
-    private TextField messageField;
-    @FXML
-    private TextArea messageArea;
-    @FXML
-    private Button connectButton;
-    @FXML
-    private TextField filterValue;
-    @FXML
-    private Button sendButton;
+    @FXML private Pane rootPane;
+    @FXML private TextField serverAddressField;
+    @FXML private TextField serverPortField;
+    @FXML private TextField userNameField;
+    @FXML private TextField messageField;
+    @FXML private TextArea messageArea;
+    @FXML private Button connectButton;
+    @FXML private Button sendButton;
+    @FXML private TextField filterValue;
 
 
-    /**
-     * Takes a message object and stores it used as Model and also starts message Listener via messageListener method.
-     *
-     * @param messages Object that will be set for use as Model
-     */
+    @FXML
+    public void initialize() {
+        serverAddressField.setText(NetworkHandler.DEFAULT_ADDRESS.getCanonicalHostName());
+        serverPortField.setText(String.valueOf(NetworkHandler.DEFAULT_PORT));
+    }
+
     public void setMessages(ClientMessageList messages) {
         this.messages = messages;
         messageListener();
     }
 
-    /**
-     * Takes a Connection handler object and stores it used as Model and also starts a Listener for it.
-     *
-     * @param connectionHandler that will be set and used as Model.
-     */
-    public void setConnectionHandler(ClientConnectionHandler connectionHandler) {
+    public void setConnectionHandler(ClientConnectionHandler connectionHandler){
         this.connectionHandler = connectionHandler;
-        startConnectionHandlerListener();
-        serverAddressField.setText(connectionHandler.getServerAddressProperty().get());
-        serverPortField.setText(String.valueOf(connectionHandler.getServerPortProperty().get()));
     }
 
-    /**
-     * Method which closes the Application via use of the disconnect Method.
-     */
     private void applicationClose() {
         disconnect();
     }
 
-    /**
-     * Method that handles the Connect Button and Initiates connect when connectionHandler is not Connected or
-     * a disconnect when it is connected.
-     */
     @FXML
-    private void toggleConnection() {
+    private void toggleConnection () {
         if (connectionHandler == null || connectionHandler.getStateProperty().get() != CONNECTED) {
             connect();
         } else {
@@ -91,22 +64,16 @@ public class ChatWindowController {
         }
     }
 
-    /**
-     * Initiates a connection by starting Connection Handler and telling, the Handler to start a connection.
-     */
     private void connect() {
         try {
             messages.clear(); // clear message list
             startConnectionHandler();
             connectionHandler.connect();
-        } catch (ChatProtocolException | IOException e) {
-            addError("Error while starting Connection Handler and connect" + e);
+        } catch(ChatProtocolException | IOException e) {
+            addError(e.getMessage());
         }
     }
 
-    /**
-     * Initiates disconnecting of the connectionHandler, also checks if connectionHandler is available.
-     */
     private void disconnect() {
         if (connectionHandler == null) {
             addError("No connection handler");
@@ -119,9 +86,6 @@ public class ChatWindowController {
         }
     }
 
-    /**
-     * Method which is used when the send button is pressed and handing over a message to the Connection Handler
-     */
     @FXML
     private void message() {
         String messageString = messageField.getText().strip();
@@ -138,40 +102,29 @@ public class ChatWindowController {
         }
     }
 
-    /**
-     * Method which is used when a Filter is applied
-     * Setting the Text in the message area after sending it through the filter.
-     */
     @FXML
-    private void applyFilter() {
-        Platform.runLater(() -> this.messageArea.setText(messages.getFilteredMessages(filterValue.getText().strip())));
+    private void applyFilter( ) {
+    	this.redrawMessageList();
     }
 
-    /**
-     * Starts the ConnectionHandler setting the username and Checking if the name follows the valid format of no spaces.
-     *
-     * @throws IOException for error that may occur during initialization of connectionHandler.
-     */
     private void startConnectionHandler() throws IOException {
         String userName = userNameField.getText();
-        if (!userName.contains(" ")) {
+        if(!userName.contains(" ")) {
             String serverAddress = serverAddressField.getText();
             int serverPort = Integer.parseInt(serverPortField.getText());
             connectionHandler.initialize(serverAddress, serverPort, userName);
             new Thread(connectionHandler).start();
 
+            //register Listener
+            startListener();
+
+            // register window close handler
             rootPane.getScene().getWindow().addEventHandler(WindowEvent.WINDOW_CLOSE_REQUEST, windowCloseHandler);
         } else {
             addError("It is not allowed to have spaces in username!");
         }
     }
 
-    /**
-     * Sets the state shown according to the state the method receives, if state indicates disconnected it will also inform the
-     * Connection Handler and tell it to stop Receiving more messages.
-     *
-     * @param newState is the state that it should be set to.
-     */
     public void stateChanged(State newState) {
         // update UI (need to be run in UI thread: see Platform.runLater())
         Platform.runLater(new Runnable() {
@@ -180,16 +133,11 @@ public class ChatWindowController {
                 connectButton.setText((newState == CONNECTED || newState == CONFIRM_DISCONNECT) ? "Disconnect" : "Connect");
             }
         });
-        if (newState == DISCONNECTED) {
+        if(newState == DISCONNECTED){
             connectionHandler.stopReceiving();
         }
     }
 
-    /**
-     * Sets displayed username according to the String provided.
-     *
-     * @param userName provided String that is set as name.
-     */
     public void setUserName(String userName) {
         Platform.runLater(new Runnable() {
             @Override
@@ -199,11 +147,6 @@ public class ChatWindowController {
         });
     }
 
-    /**
-     * Sets displayed Server Address.
-     *
-     * @param serverAddress provided String that is set as server address.
-     */
     public void setServerAddress(String serverAddress) {
         Platform.runLater(new Runnable() {
             @Override
@@ -213,11 +156,6 @@ public class ChatWindowController {
         });
     }
 
-    /**
-     * Sets displayed Server port.
-     *
-     * @param serverPort provided String that is set as server port.
-     */
     public void setServerPort(int serverPort) {
         Platform.runLater(new Runnable() {
             @Override
@@ -227,32 +165,23 @@ public class ChatWindowController {
         });
     }
 
-    /**
-     * Method which adds an incoming String as an Error Message.
-     *
-     * @param message String to be added as Error
-     */
     public void addError(String message) {
-        messages.addMessage(new Message(ConnectionHandler.DATA_TYPE.DATA_TYPE_ERROR, null, null, message));
+        messages.addMessage(new Message(Message.MessageType.ERROR, null, null, message));
     }
 
-    /**
-     * Nested Class in charge of Closing the window
-     */
-    class WindowCloseHandler implements EventHandler<WindowEvent> {
+    private void redrawMessageList() {
+        this.messageArea.clear();
+        Platform.runLater(() -> this.messageArea.setText(messages.getFilteredMessages(filterValue.getText().strip())));
+    }
 
-        /**
-         * @param event the event which occurred when Windows is closed
-         */
+    class WindowCloseHandler implements EventHandler<WindowEvent> {
         public void handle(WindowEvent event) {
             applicationClose();
         }
+
     }
 
-    /**
-     * Starts several new Listener for Connection Handler changes by using several observable properties.
-     */
-    public void startConnectionHandlerListener() {
+    public void startListener() {
         connectionHandler.getStateProperty().addListener(new ChangeListener<State>() {
             @Override
             public void changed(ObservableValue<? extends State> observable, State oldValue, State newValue) {
@@ -282,14 +211,11 @@ public class ChatWindowController {
         });
     }
 
-    /**
-     * Starts a new Listener for messages by using the observable Boolean.
-     */
     private void messageListener() {
         messages.getChangedProperty().addListener(new ChangeListener<Boolean>() {
             @Override
             public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
-                Platform.runLater(() -> messageArea.setText(messages.getFilteredMessages(filterValue.getText().strip())));
+                redrawMessageList();
             }
         });
     }

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

@@ -2,16 +2,8 @@ package ch.zhaw.pm2.multichat.client;
 
 import javafx.application.Application;
 
-/**
- * Client Main Class in charge of starting the UI only contains main method.
- */
 public class Client {
 
-    /**
-     * Main method which launches the Client UI
-     *
-     * @param args no arguments needed
-     */
     public static void main(String[] args) {
         // Start UI
         System.out.println("Starting Client Application");

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

@@ -2,7 +2,6 @@ package ch.zhaw.pm2.multichat.client;
 
 import ch.zhaw.pm2.multichat.protocol.ChatProtocolException;
 import ch.zhaw.pm2.multichat.protocol.ConnectionHandler;
-import ch.zhaw.pm2.multichat.protocol.Message;
 import ch.zhaw.pm2.multichat.protocol.NetworkHandler;
 import javafx.beans.property.SimpleIntegerProperty;
 import javafx.beans.property.SimpleObjectProperty;
@@ -14,119 +13,66 @@ import java.net.SocketException;
 import java.util.Scanner;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-
 import static ch.zhaw.pm2.multichat.protocol.ConnectionHandler.State.*;
 
-/**
- * Client Connection Handler Class is used for the connection of the Client to a server
- * it is used part as a Model storing properties like userName, state, serverAddress and Port.
- * Also holds methods to
- */
 public class ClientConnectionHandler extends ConnectionHandler implements Runnable {
 
-    private final Pattern messagePattern = Pattern.compile("^(?:@(\\S*))?\\s*(.*)$");
+    private final Pattern messagePattern = Pattern.compile( "^(?:@(\\S*))?\\s*(.*)$" );
 
-    private final SimpleStringProperty userName;
-    private final SimpleObjectProperty<State> state;
-    private final ClientMessageList messages;
-    private final SimpleStringProperty serverAddress;
-    private final SimpleIntegerProperty serverPort;
+    private SimpleStringProperty userName;
+    private SimpleObjectProperty<State> state;
+    private ClientMessageList messages;
+    private SimpleStringProperty serverAddress;
+    private SimpleIntegerProperty serverPort;
 
-    /**
-     * Constructor initializes ConnectionHandler by Setting default values for the fields and stores the given messages itself.
-     *
-     * @param messages
-     */
-    public ClientConnectionHandler(ClientMessageList messages) {
+    public ClientConnectionHandler(ClientMessageList messages)  {
         super();
         this.messages = messages;
         state = new SimpleObjectProperty<>(State.NEW);
-        serverAddress = new SimpleStringProperty(NetworkHandler.DEFAULT_ADDRESS.getCanonicalHostName());
-        serverPort = new SimpleIntegerProperty(NetworkHandler.DEFAULT_PORT);
-        this.userName = new SimpleStringProperty(null);
+        serverAddress = new SimpleStringProperty();
+        serverPort = new SimpleIntegerProperty();
     }
 
-    /**
-     * Called to initialize the ClientConnectionHandler when trying to start a connection
-     *
-     * @param serverAddress to connect to
-     * @param serverPort    to connect to
-     * @param userName      to connect as
-     * @throws IOException if connection to Server not possible
-     */
     public void initialize(String serverAddress, int serverPort, String userName) throws IOException {
-        state.set(NEW);
-        this.serverAddress.set(serverAddress);
-        this.serverPort.set(serverPort);
-        setConnection(NetworkHandler.openConnection(serverAddress, serverPort));
-        this.userName.set((userName == null || userName.isBlank()) ? USER_NONE : userName);
+        this.state = new SimpleObjectProperty<>(NEW);
+        this.serverAddress = new SimpleStringProperty(serverAddress);
+        this.serverPort = new SimpleIntegerProperty(serverPort);
+        this.userName = new SimpleStringProperty((userName == null || userName.isBlank())? USER_NONE : userName);
+        try {
+            setConnection(NetworkHandler.openConnection(this.serverAddress.get(), this.serverPort.get()));
+        } catch (IOException e) {
+            messages.addMessage(new Message(Message.MessageType.ERROR,null,null,e.getMessage()));
+            System.out.println("ERROR: " + e.getMessage());
+        }
     }
 
-    /**
-     * Observable getter Method for the stored serverAddress
-     *
-     * @return the stored serverAddress
-     */
-    public SimpleStringProperty getServerAddressProperty() {
-        return serverAddress;
-    }
+    public SimpleStringProperty getServerAddressProperty() { return serverAddress; }
 
-    /**
-     * Observable getter Method for the stored serverPort
-     *
-     * @return the stored serverPort
-     */
-    public SimpleIntegerProperty getServerPortProperty() {
-        return serverPort;
-    }
+    public SimpleIntegerProperty getServerPortProperty() { return serverPort; }
 
-    /**
-     * Observable getter Method for the stored state
-     *
-     * @return the stored state
-     */
     public SimpleObjectProperty<State> getStateProperty() {
         return this.state;
     }
 
-    /**
-     * Observable getter Method for the stored userName
-     *
-     * @return the stored userName
-     */
-    public SimpleStringProperty getUserNameProperty() {
-        return userName;
-    }
+    public SimpleStringProperty getUserNameProperty() { return userName; }
 
-    /**
-     * Method which sets a new State.
-     *
-     * @param newState the state that will be set
-     */
-    public void setState(State newState) {
+    public void setState (State newState) {
         state.set(newState);
     }
 
-    /**
-     * Standard run method which will directly start the startReceiving method.
-     */
-    public void run() {
+    public void run () {
         startReceiving();
     }
 
-    /**
-     * Method that is started by the run method, starts a connection handler.
-     * Figures out if connection is available if not determines the error cause and gives an error accordingly.
-     */
     private void startReceiving() {
         System.out.println("Starting Connection Handler");
         try {
             System.out.println("Start receiving data...");
             while (getConnection().isAvailable()) {
-                Message data = getConnection().receive();
+                String data = getConnection().receive();
                 processData(data);
             }
-            System.out.println("Stopped receiving data");
+            System.out.println("Stopped recieving data");
         } catch (SocketException e) {
             System.out.println("Connection terminated locally");
             this.setState(DISCONNECTED);
@@ -135,17 +81,14 @@ public class ClientConnectionHandler extends ConnectionHandler implements Runnab
             System.out.println("Connection terminated by remote");
             this.setState(DISCONNECTED);
             System.err.println("Unregistered because connection terminated" + e.getMessage());
-        } catch (IOException e) {
+        } catch(IOException e) {
             System.err.println("Communication error" + e);
-        } catch (ClassNotFoundException e) {
+        } catch(ClassNotFoundException e) {
             System.err.println("Received object of unknown type" + e.getMessage());
         }
         System.out.println("Stopped Connection Handler");
     }
 
-    /**
-     * Method which is used to stop receiving data, gets the current connection and closes it.
-     */
     public void stopReceiving() {
         System.out.println("Closing Connection Handler to Server");
         try {
@@ -158,114 +101,110 @@ public class ClientConnectionHandler extends ConnectionHandler implements Runnab
         System.out.println("Closed Connection Handler to Server");
     }
 
-    /**
-     * Method which processes data and determines its type then uses the corresponding method to process it.
-     *
-     * @param data that is received in a form of a String and then used depending on its determined cause.
-     */
-    private void processData(Message data) {
-        // dispatch operation based on type parameter
-        if (data.getType() == DATA_TYPE.DATA_TYPE_CONNECT) {
-            System.err.println("Illegal connect request from server");
-        } else if (data.getType() == DATA_TYPE.DATA_TYPE_CONFIRM) {
-            caseConfirm(data);
-        } else if (data.getType() == DATA_TYPE.DATA_TYPE_DISCONNECT) {
-            caseDisconnect(data);
-        } else if (data.getType() == DATA_TYPE.DATA_TYPE_MESSAGE) {
-            caseMessage(data);
-        } else if (data.getType() == DATA_TYPE.DATA_TYPE_ERROR) {
-            caseError(data);
-        } else {
-            System.out.println("Unknown data type received: " + data.getType());
+    private void processData(String data) {
+        try {
+            // parse data content
+            Scanner scanner = new Scanner(data);
+            String sender = null;
+            String reciever = null;
+            String type = null;
+            String payload = null;
+            if (scanner.hasNextLine()) {
+                sender = scanner.nextLine();
+            } else {
+                throw new ChatProtocolException("No Sender found");
+            }
+            if (scanner.hasNextLine()) {
+                reciever = scanner.nextLine();
+            } else {
+                throw new ChatProtocolException("No Reciever found");
+            }
+            if (scanner.hasNextLine()) {
+                type = scanner.nextLine();
+            } else {
+                throw new ChatProtocolException("No Type found");
+            }
+            if (scanner.hasNextLine()) {
+                payload = scanner.nextLine();
+            }
+            // dispatch operation based on type parameter
+            if (type.equals(getDataTypeConnect())) {
+                System.err.println("Illegal connect request from server");
+            } else if (type.equals(getDataTypeConfirm())) {
+                if (state.get() == CONFIRM_CONNECT) {
+                    this.userName.set(reciever);
+                    this.serverPort.set(getConnection().getRemotePort());
+                    this.serverAddress.set(getConnection().getRemoteHost());
+                    messages.addMessage(new Message(Message.MessageType.INFO,sender,reciever,payload));
+                    System.out.println("CONFIRM: " + payload);
+                    this.setState(CONNECTED);
+                } else if (state.get() == CONFIRM_DISCONNECT) {
+                    messages.addMessage(new Message(Message.MessageType.INFO,sender,reciever,payload));
+                    System.out.println("CONFIRM: " + payload);
+                    this.setState(DISCONNECTED);
+                } else {
+                    System.err.println("Got unexpected confirm message: " + payload);
+                }
+            } else if (type.equals(getDataTypeDisconnect())) {
+                if (state.get() == DISCONNECTED) {
+                    System.out.println("DISCONNECT: Already in disconnected: " + payload);
+                    return;
+                }
+                messages.addMessage(new Message(Message.MessageType.INFO,sender,reciever,payload));
+                System.out.println("DISCONNECT: " + payload);
+                this.setState(DISCONNECTED);
+            } else if (type.equals(getDataTypeMessage())) {
+                if (state.get() != CONNECTED) {
+                    System.out.println("MESSAGE: Illegal state " + state + " for message: " + payload);
+                    return;
+                }
+                messages.addMessage(new Message(Message.MessageType.MESSAGE,sender,reciever,payload));
+                System.out.println("MESSAGE: From " + sender + " to " + reciever + ": "+  payload);
+            } else if (type.equals(getDataTypeError())) {
+                messages.addMessage(new Message(Message.MessageType.ERROR,sender,reciever,payload));
+                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.get(), getDataTypeError(), e.getMessage());
         }
     }
 
-    private void caseConfirm(Message data) {
-        if (state.get() == CONFIRM_CONNECT) {
-            this.userName.set(data.getReceiver());
-            this.serverPort.set(getConnection().getRemotePort());
-            this.serverAddress.set(getConnection().getRemoteHost());
-            messages.addMessage(data);
-            System.out.println("CONFIRM: " + data.getText());
-            this.setState(CONNECTED);
-        } else if (state.get() == CONFIRM_DISCONNECT) {
-            messages.addMessage(data);
-            System.out.println("CONFIRM: " + data.getText());
-            this.setState(DISCONNECTED);
-        } else {
-            System.err.println("Got unexpected confirm message: " + data.getText());
+    private void sendData(String sender, String receiver, String type, String payload) {
+        if (getConnection().isAvailable()) {
+            new StringBuilder();
+            String data = new StringBuilder()
+                .append(sender+"\n")
+                .append(receiver+"\n")
+                .append(type+"\n")
+                .append(payload+"\n")
+                .toString();
+            try {
+                getConnection().send(data);
+            } catch (SocketException e) {
+                System.err.println("Connection closed: " + e.getMessage());
+            } catch (EOFException e) {
+                System.out.println("Connection terminated by remote");
+            } catch(IOException e) {
+                System.err.println("Communication error: " + e.getMessage());
+            }
         }
     }
 
-    /**
-     * Initiates the disconnect sequence and sends the message with all its info.
-     *
-     * @param data Data which has been transmitted
-     */
-    private void caseDisconnect(Message data) {
-        if (state.get() == DISCONNECTED) {
-            System.out.println("DISCONNECT: Already in disconnected: " + data.getText());
-            return;
-        }
-        messages.addMessage(data);
-        System.out.println("DISCONNECT: " + data.getText());
-        this.setState(DISCONNECTED);
-    }
-
-    /**
-     * Initiates the procedure to send a new message and sends one as such.
-     *
-     * @param data Data which has been transmitted
-     */
-    private void caseMessage(Message data) {
-        if (state.get() != CONNECTED) {
-            System.out.println("MESSAGE: Illegal state " + state + " for message: " + data.getText());
-            return;
-        }
-        messages.addMessage(data);
-        System.out.println("MESSAGE: From " + data.getSender() + " to " + data.getReceiver() + ": " + data.getText());
-    }
-
-    /**
-     * Stores the message as an error message and displays it as such as well.
-     *
-     * @param data Data which has been transmitted
-     */
-    private void caseError(Message data) {
-        messages.addMessage(data);
-        System.out.println("ERROR: " + data.getText());
-    }
-
-    /**
-     * Send connect attempt to Server
-     *
-     * @throws ChatProtocolException Error that is thrown if the state is not set to NEW
-     */
     public void connect() throws ChatProtocolException {
         if (state.get() != NEW) throw new ChatProtocolException("Illegal state for connect: " + state);
-        this.sendData(userName.get(), USER_NONE, getDataTypeConnect(), null);
+        this.sendData(userName.get(), USER_NONE, getDataTypeConnect(),null);
         this.setState(CONFIRM_CONNECT);
     }
 
-    /**
-     * Send Disconnect attempt to server
-     *
-     * @throws ChatProtocolException Error tha si thrown if state is invalid
-     */
     public void disconnect() throws ChatProtocolException {
-        if (state.get() != NEW && state.get() != CONNECTED)
-            throw new ChatProtocolException("Illegal state for disconnect: " + state);
-        this.sendData(userName.get(), USER_NONE, getDataTypeDisconnect(), null);
+        if (state.get() != NEW && state.get() != CONNECTED) throw new ChatProtocolException("Illegal state for disconnect: " + state);
+        this.sendData(userName.get(), USER_NONE, getDataTypeDisconnect(),null);
         this.setState(CONFIRM_DISCONNECT);
     }
 
-    /**
-     * Sends message to Server
-     *
-     * @param messageString The message the user wants to send
-     * @return true if message is valid else false
-     * @throws ChatProtocolException if illegal connection state
-     */
     public boolean message(String messageString) throws ChatProtocolException {
         if (state.get() != CONNECTED) throw new ChatProtocolException("Illegal state for message: " + state);
 
@@ -273,14 +212,15 @@ public class ClientConnectionHandler extends ConnectionHandler implements Runnab
         if (matcher.find()) {
             String receiver = matcher.group(1);
             String message = matcher.group(2);
-            if (message.length() < 1) {
+            if(message.length() < 1){
                 return false;
             }
             if (receiver == null || receiver.isBlank()) receiver = ClientConnectionHandler.USER_ALL;
-            this.sendData(userName.get(), receiver, getDataTypeMessage(), message);
+            this.sendData(userName.get(), receiver, getDataTypeMessage(),message);
             return true;
         } else {
             return false;
         }
     }
+
 }

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

@@ -1,68 +1,41 @@
 package ch.zhaw.pm2.multichat.client;
 
-import ch.zhaw.pm2.multichat.protocol.ConnectionHandler;
-import ch.zhaw.pm2.multichat.protocol.Message;
 import javafx.beans.property.SimpleBooleanProperty;
 
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * Class that is used to store the messages in an ArrayList
- * And also as a Model that informs the controller via Listeners that can be initialized
- */
 public class ClientMessageList {
     private List<Message> messages = new ArrayList<>();
-    private final SimpleBooleanProperty changed = new SimpleBooleanProperty(false);
+    private SimpleBooleanProperty changed = new SimpleBooleanProperty(false);
 
-    /**
-     * Adds a new message to ArrayList and also informs Listener.
-     *
-     * @param message that should be added
-     */
     public void addMessage(Message message) {
-        messages.add(message);
-        changed.set(!changed.get());
+	    messages.add(message);
+	    changed.set(!changed.get());
     }
 
-    /**
-     * Applies a given filter over all messages and returns the result as a new String.
-     * Method is also in charge of applying the correct prefix to the message according to its type.
-     *
-     * @param filter is the applied filter on all the messages that are stored.
-     * @return String that matches the given filter.
-     */
-    public String getFilteredMessages(String filter) {
+	public String getFilteredMessages(String filter) {
         StringBuilder result = new StringBuilder();
-        boolean showAll = filter == null || filter.isBlank();
-        for (Message message : messages) {
-            if (showAll || message.matchesFilter(filter)) {
+		boolean showAll = filter == null || filter.isBlank();
+		for(Message message : messages) {
+			if(showAll || message.matchesFilter(filter))
+			{
                 switch (message.getType()) {
-                    case DATA_TYPE_MESSAGE -> result.append(String.format("[%s -> %s] %s\n", message.getSender(), message.getReceiver(), message.getText()));
-                    case DATA_TYPE_ERROR -> result.append(String.format("[ERROR] %s\n", message.getText()));
-                    case DATA_TYPE_CONFIRM, DATA_TYPE_DISCONNECT, DATA_TYPE_CONNECT -> result.append(String.format("[INFO] %s\n", message.getText()));
+                    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();
-    }
+	}
 
-    /**
-     * Overwrites the Arraylist of messages, clearing it, also informs all Listeners.
-     */
     public void clear() {
         messages = new ArrayList<>();
         changed.set(!changed.get());
     }
 
-    /**
-     * Getter Method to check the current value of SimpleBooleanProperty changed.
-     *
-     * @return the current value of changed
-     */
-    public SimpleBooleanProperty getChangedProperty() {
-        return changed;
-    }
+    public SimpleBooleanProperty getChangedProperty() { return changed; }
 
 }

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

@@ -6,32 +6,15 @@ import javafx.scene.Scene;
 import javafx.scene.layout.Pane;
 import javafx.stage.Stage;
 
-/**
- * Class in charge of initializing and loading elements needed for the GUI.
- * Also Launching the chat window with pre-given parameters
- */
 public class ClientUI extends Application {
-    private final ClientMessageList clientMessageList = new ClientMessageList();
-    private final ClientConnectionHandler connectionHandler = new ClientConnectionHandler(clientMessageList);
+    private ClientMessageList clientMessageList = new ClientMessageList();
+    private ClientConnectionHandler connectionHandler = new ClientConnectionHandler(clientMessageList);
 
-    /**
-     * Start method will only run the chatWindow method.
-     *
-     * @param primaryStage the primary stage for this application, onto which
-     *                     the application scene can be set.
-     *                     Applications may create other stages, if needed, but they will not be
-     *                     primary stages.
-     */
     @Override
     public void start(Stage primaryStage) {
         chatWindow(primaryStage);
     }
 
-    /**
-     * Method is in charge of loading the FXML file and then initializing the controllers and setting some parameters for the stage.
-     *
-     * @param primaryStage of the Application onto which the Scene is set.
-     */
     private void chatWindow(Stage primaryStage) {
         try {
             FXMLLoader loader = new FXMLLoader(getClass().getResource("ChatWindow.fxml"));
@@ -51,7 +34,7 @@ public class ClientUI extends Application {
             primaryStage.setTitle("Multichat Client");
             primaryStage.show();
             primaryStage.setMinWidth(primaryStage.getWidth()); //use automatically computed size as Minimum Size.
-        } catch (Exception e) {
+        } catch(Exception e) {
             System.err.println("Error starting up UI" + e.getMessage());
         }
     }

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;
+    }
+}

client/src/main/resources/ch/zhaw/pm2/multichat/client/ChatWindow.fxml

@@ -12,82 +12,74 @@
 <?import javafx.scene.layout.HBox?>
 <?import javafx.scene.layout.VBox?>
 
-<BorderPane xmlns:fx="http://javafx.com/fxml/1" fx:id="rootPane" minWidth="-Infinity" prefHeight="500.0"
-            prefWidth="420.0" xmlns="http://javafx.com/javafx/18"
-            fx:controller="ch.zhaw.pm2.multichat.client.ChatWindowController">
-    <top>
-        <VBox BorderPane.alignment="CENTER">
-            <children>
-                <MenuBar>
-                    <menus>
-                        <Menu mnemonicParsing="false" text="Filter">
-                            <items>
-                                <MenuItem mnemonicParsing="false" text="press Enter">
-                                    <graphic>
-                                        <TextField fx:id="filterValue" onAction="#applyFilter"/>
-                                    </graphic>
-                                </MenuItem>
-                            </items>
-                        </Menu>
-                    </menus>
-                </MenuBar>
-                <HBox fillHeight="false" spacing="5.0">
-                    <children>
-                        <TextField fx:id="userNameField" alignment="CENTER_RIGHT" maxWidth="1.7976931348623157E308"
-                                   minWidth="110.0" promptText="Username" HBox.hgrow="SOMETIMES"/>
-                        <Label alignment="CENTER" contentDisplay="CENTER" text="\@" textAlignment="CENTER"
-                               textOverrun="CLIP" HBox.hgrow="NEVER">
-                            <HBox.margin>
-                                <Insets bottom="5.0" top="5.0"/>
-                            </HBox.margin>
-                        </Label>
-                        <TextField fx:id="serverAddressField" alignment="CENTER_RIGHT" minWidth="110.0"
-                                   promptText="Host" HBox.hgrow="SOMETIMES"/>
-                        <Label text=":" HBox.hgrow="NEVER">
-                            <HBox.margin>
-                                <Insets bottom="5.0" top="5.0"/>
-                            </HBox.margin>
-                        </Label>
-                        <TextField fx:id="serverPortField" minWidth="-Infinity" prefWidth="60.0" promptText="Port"
-                                   HBox.hgrow="NEVER"/>
-                        <Button fx:id="connectButton" maxWidth="-Infinity" minWidth="-Infinity" mnemonicParsing="false"
-                                onAction="#toggleConnection" prefWidth="80.0" text="Connect" HBox.hgrow="NEVER">
-                            <HBox.margin>
-                                <Insets left="5.0"/>
-                            </HBox.margin>
-                        </Button>
-                    </children>
-                    <BorderPane.margin>
-                        <Insets/>
-                    </BorderPane.margin>
-                    <padding>
-                        <Insets bottom="5.0" left="5.0" right="5.0" top="5.0"/>
-                    </padding>
-                </HBox>
-            </children>
-        </VBox>
-    </top>
-    <bottom>
-        <HBox spacing="5.0">
-            <children>
-                <TextField fx:id="messageField" onAction="#message" HBox.hgrow="ALWAYS"/>
-                <Button fx:id="sendButton" alignment="CENTER" maxWidth="-Infinity" minWidth="-Infinity"
-                        mnemonicParsing="false" onAction="#message" prefWidth="50.0" text="Send" textAlignment="CENTER">
-                    <HBox.margin>
-                        <Insets left="5.0"/>
-                    </HBox.margin>
-                </Button>
-            </children>
-            <padding>
-                <Insets bottom="5.0" left="5.0" right="5.0" top="5.0"/>
-            </padding>
-        </HBox>
-    </bottom>
-    <center>
-        <TextArea fx:id="messageArea" editable="false" wrapText="true">
-            <BorderPane.margin>
-                <Insets left="5.0" right="5.0"/>
-            </BorderPane.margin>
-        </TextArea>
-    </center>
+<BorderPane fx:id="rootPane" minWidth="-Infinity" prefHeight="500.0" prefWidth="420.0" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.pm2.multichat.client.ChatWindowController">
+   <top>
+      <VBox BorderPane.alignment="CENTER">
+         <children>
+            <MenuBar>
+              <menus>
+                <Menu mnemonicParsing="false" text="Filter">
+                  <items>
+                    <MenuItem mnemonicParsing="false" text="press Enter">
+                           <graphic>
+                              <TextField fx:id="filterValue" onAction="#applyFilter" />
+                           </graphic>
+                        </MenuItem>
+                  </items>
+                </Menu>
+              </menus>
+            </MenuBar>
+	      <HBox fillHeight="false" spacing="5.0">
+	         <children>
+	            <TextField fx:id="userNameField" alignment="CENTER_RIGHT" maxWidth="1.7976931348623157E308" minWidth="110.0" promptText="Username" HBox.hgrow="SOMETIMES" />
+	            <Label alignment="CENTER" contentDisplay="CENTER" text="\@" textAlignment="CENTER" textOverrun="CLIP" HBox.hgrow="NEVER">
+	               <HBox.margin>
+	                  <Insets bottom="5.0" top="5.0" />
+	               </HBox.margin>
+	            </Label>
+	            <TextField fx:id="serverAddressField" alignment="CENTER_RIGHT" minWidth="110.0" promptText="Host" HBox.hgrow="SOMETIMES" />
+	            <Label text=":" HBox.hgrow="NEVER">
+	               <HBox.margin>
+	                  <Insets bottom="5.0" top="5.0" />
+	               </HBox.margin>
+	            </Label>
+	            <TextField fx:id="serverPortField" minWidth="-Infinity" prefWidth="60.0" promptText="Port" HBox.hgrow="NEVER" />
+	            <Button fx:id="connectButton" maxWidth="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#toggleConnection" prefWidth="80.0" text="Connect" HBox.hgrow="NEVER">
+	               <HBox.margin>
+	                  <Insets left="5.0" />
+	               </HBox.margin>
+	            </Button>
+	         </children>
+	         <BorderPane.margin>
+	            <Insets />
+	         </BorderPane.margin>
+	         <padding>
+	            <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
+	         </padding>
+	      </HBox>
+         </children>
+      </VBox>
+   </top>
+   <bottom>
+      <HBox spacing="5.0">
+         <children>
+            <TextField fx:id="messageField" onAction="#message" HBox.hgrow="ALWAYS" />
+            <Button fx:id="sendButton" alignment="CENTER" maxWidth="-Infinity" minWidth="-Infinity" mnemonicParsing="false" onAction="#message" prefWidth="50.0" text="Send" textAlignment="CENTER">
+               <HBox.margin>
+                  <Insets left="5.0" />
+               </HBox.margin>
+            </Button>
+         </children>
+         <padding>
+            <Insets bottom="5.0" left="5.0" right="5.0" top="5.0" />
+         </padding>
+      </HBox>
+   </bottom>
+   <center>
+      <TextArea fx:id="messageArea" editable="false" wrapText="true">
+         <BorderPane.margin>
+            <Insets left="5.0" right="5.0" />
+         </BorderPane.margin>
+      </TextArea>
+   </center>
 </BorderPane>

protocol/src/main/java/ch/zhaw/pm2/multichat/protocol/ConnectionHandler.java

@@ -1,101 +1,47 @@
 package ch.zhaw.pm2.multichat.protocol;
 
-import java.io.EOFException;
-import java.io.IOException;
-import java.net.SocketException;
-
-/**
- * This abstract class is the superclass for ClientConnectionHandler and ServerConnectionHandler
- * It offers the DATA_TYPE for message and a {@link State} enum for all valid connection states.
- * Shared methods are implemented in this class as well {@link ConnectionHandler#sendData(String, String, DATA_TYPE, String)}
- */
 public abstract class ConnectionHandler {
     private NetworkHandler.NetworkConnection<String> connection;
 
+    // Data types used for the Chat Protocol
+    private static final String DATA_TYPE_CONNECT = "CONNECT";
+    private static final String DATA_TYPE_CONFIRM = "CONFIRM";
+    private static final String DATA_TYPE_DISCONNECT = "DISCONNECT";
+    private static final String DATA_TYPE_MESSAGE = "MESSAGE";
+    private static final String DATA_TYPE_ERROR = "ERROR";
+
     public static final String USER_NONE = "";
     public static final String USER_ALL = "*";
 
-    // State of the connection
     public enum State {
         NEW, CONFIRM_CONNECT, CONNECTED, CONFIRM_DISCONNECT, DISCONNECTED, ERROR;
     }
 
-    // DATA_TYPE of the messages
-    public enum DATA_TYPE {
-        DATA_TYPE_CONNECT, DATA_TYPE_CONFIRM, DATA_TYPE_DISCONNECT, DATA_TYPE_MESSAGE, DATA_TYPE_ERROR
+    public static String getDataTypeConnect() {
+        return DATA_TYPE_CONNECT;
     }
 
-    /**
-     * @return {@link DATA_TYPE}
-     */
-    public static DATA_TYPE getDataTypeConnect() {
-        return DATA_TYPE.DATA_TYPE_CONNECT;
+    public static String getDataTypeConfirm() {
+        return DATA_TYPE_CONFIRM;
     }
 
-    /**
-     * @return {@link DATA_TYPE}
-     */
-    public static DATA_TYPE getDataTypeConfirm() {
-        return DATA_TYPE.DATA_TYPE_CONFIRM;
+    public static String getDataTypeDisconnect() {
+        return DATA_TYPE_DISCONNECT;
     }
 
-    /**
-     * @return {@link DATA_TYPE}
-     */
-    public static DATA_TYPE getDataTypeDisconnect() {
-        return DATA_TYPE.DATA_TYPE_DISCONNECT;
+    public static String getDataTypeMessage() {
+        return DATA_TYPE_MESSAGE;
     }
 
-    /**
-     * @return {@link DATA_TYPE}
-     */
-    public static DATA_TYPE getDataTypeMessage() {
-        return DATA_TYPE.DATA_TYPE_MESSAGE;
+    public static String getDataTypeError() {
+        return DATA_TYPE_ERROR;
     }
 
-    /**
-     * @return {@link DATA_TYPE}
-     */
-    public static DATA_TYPE getDataTypeError() {
-        return DATA_TYPE.DATA_TYPE_ERROR;
-    }
-
-    /**
-     * @return {@link NetworkHandler.NetworkConnection}
-     */
     public NetworkHandler.NetworkConnection<String> getConnection() {
         return connection;
     }
 
-    /**
-     * This method sets the NetworkConnection used for the server <-> client connection
-     *
-     * @param connection NetworkConnection used for the server <-> client connection
-     */
     protected void setConnection(NetworkHandler.NetworkConnection<String> connection) {
         this.connection = connection;
     }
-
-
-    /**
-     * This method gets called to send data via the socket defined in the {@link NetworkHandler.NetworkConnection}
-     *
-     * @param sender   of the data
-     * @param receiver of the data
-     * @param type     of the data
-     * @param payload  of the data
-     */
-    protected void sendData(String sender, String receiver, DATA_TYPE type, String payload) {
-        if (connection.isAvailable()) {
-            try {
-                connection.send(new Message(type, sender, receiver, payload));
-            } catch (SocketException e) {
-                System.err.println("Connection closed: " + e.getMessage());
-            } catch (EOFException e) {
-                System.out.println("Connection terminated by remote");
-            } catch (IOException e) {
-                System.err.println("Communication error: " + e.getMessage());
-            }
-        }
-    }
 }

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

@@ -1,69 +0,0 @@
-package ch.zhaw.pm2.multichat.protocol;
-
-import java.io.Serializable;
-
-/**
- * A Message object represents one Message of a client. Can be stored in ClientMessageList.
- */
-public class Message implements Serializable {
-    private final ConnectionHandler.DATA_TYPE type;
-    private final String sender;
-    private final String receiver;
-    private final 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 receiver will be null)
-     * @param sender   The User who has sent the message.
-     * @param receiver The User who should receive the message.
-     * @param text     The Text of the message.
-     */
-    public Message(ConnectionHandler.DATA_TYPE 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 data fields sender, receiver or text
-     *
-     * @param filter The Filter String
-     * @return true if it is the Filter String is contained in a data field.
-     */
-    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 ConnectionHandler.DATA_TYPE getType() {
-        return type;
-    }
-
-    /**
-     * @return The User who has sent the Message.
-     */
-    public String getSender() {
-        return sender;
-    }
-
-    /**
-     * @return The Receiver who receives the Message.
-     */
-    public String getReceiver() {
-        return receiver;
-    }
-
-    /**
-     * @return The Text of the Message.
-     */
-    public String getText() {
-        return text;
-    }
-
-}

protocol/src/main/java/ch/zhaw/pm2/multichat/protocol/NetworkHandler.java

@@ -38,7 +38,7 @@ import java.util.Objects;
  *             on the client side, usually the result is displayed to the user). After processing is finished the
  *             process calls {@link NetworkConnection#receive()} again to wait for the next request.
  *             </li>
- *             <li>sending data: call {@link NetworkConnection#send(Message)}, which sends the given data
+ *             <li>sending data: call {@link NetworkConnection#send(Serializable data)}, which sends the given data
  *             object to the remote side. The method returns as soon the object has been transmitted.
  *             <b>Important: {@link NetworkConnection} is not thread safe</b>, therefore make sure that only one thread
  *             at a time is sending data.</li>
@@ -270,7 +270,7 @@ public class NetworkHandler {
      *         on the client side, usually the result is displayed to the user). After processing is finished the
      *         process calls {@link NetworkConnection#receive()} again to wait for the next request.
      *     </li>
-     *     <li>sending data: call {@link NetworkConnection#send(Message)}, which sends the given data
+     *     <li>sending data: call {@link NetworkConnection#send(Serializable data)}, which sends the given data
      *         object to the remote side. The method returns as soon the object has been transmitted.
      *         <b>Important: {@link NetworkConnection} is not thread safe</b>, therefore make sure that only one thread
      *         at a time is sending data.
@@ -305,7 +305,7 @@ public class NetworkHandler {
          * @param data  data object of type T to be submitted through the connection.
          * @throws IOException if an error occurs (e.g. connection interrupted while sending, ...)
          */
-        public synchronized void send(Message data) throws IOException {
+        public synchronized void send(T data) throws IOException {
             ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream());
             outputStream.writeObject(data);
         }
@@ -320,9 +320,9 @@ public class NetworkHandler {
          * @throws IOException if an error occours. (e.g. terminated locally/remotely) see above.
          * @throws ClassNotFoundException if the data object received does not match any class in the local classpath
          */
-        public Message receive() throws IOException, ClassNotFoundException {
+        public T receive() throws IOException, ClassNotFoundException {
             ObjectInputStream inputStream = new ObjectInputStream(this.socket.getInputStream());
-            return (Message) inputStream.readObject();
+            return (T) inputStream.readObject();
         }
 
         /**

server/src/main/java/ch/zhaw/pm2/multichat/server/Server.java

@@ -1,45 +1,24 @@
 package ch.zhaw.pm2.multichat.server;
 
+import ch.zhaw.pm2.multichat.protocol.ConnectionHandler;
 import ch.zhaw.pm2.multichat.protocol.NetworkHandler;
 
 import java.io.IOException;
 import java.net.SocketException;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
 
 
-/**
- * This Class represents a Server. The user can start the programm with the port number as a argument.
- * If no argument has been set the {@link NetworkHandler#DEFAULT_PORT} is used as port number.
- * After initialising the server:
- * 1. Starts a Socketserver using the logic given in {@link NetworkHandler.NetworkServer#createServer()}
- * 2. The server starts to listen for incoming connection using the Logic given in {@link NetworkHandler.NetworkServer#waitForConnection()}
- * 3. New connections will be attached to a Connection handler: {@link ServerConnectionHandler} and placed in a Map containing all active connections {@link Server#connections}
- */
 public class Server {
 
     // Server connection
-    private final NetworkHandler.NetworkServer<String> networkServer;
+    private NetworkHandler.NetworkServer<String> networkServer;
 
     // Connection registry
-    private final Map<String, ServerConnectionHandler> connections = new HashMap<>();
+    private Map<String,ServerConnectionHandler> connections = new HashMap<>();
 
-    /**
-     * The Constructor to create a new instance.
-     *
-     * @param serverPort to listen for incoming connections.
-     * @throws IOException thrown if an I/O error occurs when opening the socket.
-     */
-    public Server(int serverPort) throws IOException {
-        // Open server connection
-        System.out.println("Create server connection");
-        networkServer = NetworkHandler.createServer(serverPort);
-        System.out.println("Listening on " + networkServer.getHostAddress() + ":" + networkServer.getHostPort());
-    }
-
-    /**
-     * @param args
-     */
     public static void main(String[] args) {
         // Parse arguments for server port.
         try {
@@ -78,30 +57,53 @@ public class Server {
         }
     }
 
-    /**
-     * With this methode the instance waits for incoming connections. If a client tries to connect to the server.
-     * The connection will be registered in the connection registry if successful.
-     */
+    public Server(int serverPort) throws IOException {
+        // Open server connection
+        System.out.println("Create server connection");
+        networkServer = NetworkHandler.createServer(serverPort);
+        System.out.println("Listening on " + networkServer.getHostAddress() + ":" + networkServer.getHostPort());
+    }
+
     private void start() {
+        ReentrantLock mutex = new ReentrantLock();
+        Condition nameComplete = mutex.newCondition();
         System.out.println("Server started.");
         try {
-            while (networkServer.isAvailable()) {
-                NetworkHandler.NetworkConnection<String> connection = networkServer.waitForConnection();
-                ServerConnectionHandler connectionHandler = new ServerConnectionHandler(connection, connections);
-                new Thread(connectionHandler).start();
+            while (true) {
+                 NetworkHandler.NetworkConnection<String> connection = networkServer.waitForConnection();
+                 ServerConnectionHandler connectionHandler = new ServerConnectionHandler(connection, connections, mutex, nameComplete);
+                 new Thread(connectionHandler).start();
+                 mutex.lock();
+                 try {
+                     nameComplete.await();
+                     if(connectionHandler.getState() == ConnectionHandler.State.ERROR) {
+                         System.out.println(String.format("Connecting failed for new Client with IP:Port <%s:%d>.\nReason: Name already taken.",
+                                 connection.getRemoteHost(),
+                                 connection.getRemotePort()));
+                     }
+                     else {
+                         System.out.println(String.format("Connected new Client %s with IP:Port <%s:%d>",
+                                 connectionHandler.getUserName(),
+                                 connection.getRemoteHost(),
+                                 connection.getRemotePort()));
+                     }
+                 }
+                finally {
+                     mutex.unlock();
+                 }
             }
-        } catch (SocketException e) {
+        } catch(SocketException e) {
             System.out.println("Server connection terminated");
-        } catch (IOException e) {
+        }
+        catch (IOException e) {
             System.err.println("Communication error " + e);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
         }
         // close server
         System.out.println("Server Stopped.");
     }
 
-    /**
-     * This method will stop the serversocket.
-     */
     public void terminate() {
         try {
             System.out.println("Close server port.");

server/src/main/java/ch/zhaw/pm2/multichat/server/ServerConnectionHandler.java

@@ -2,104 +2,80 @@ package ch.zhaw.pm2.multichat.server;
 
 import ch.zhaw.pm2.multichat.protocol.ChatProtocolException;
 import ch.zhaw.pm2.multichat.protocol.ConnectionHandler;
-
 import static ch.zhaw.pm2.multichat.protocol.ConnectionHandler.State.*;
-
-import ch.zhaw.pm2.multichat.protocol.Message;
 import ch.zhaw.pm2.multichat.protocol.NetworkHandler;
 
 import java.io.EOFException;
 import java.io.IOException;
 import java.net.SocketException;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Scanner;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 
 
-/**
- * This class represents the connection between the server and a client and offers the serverside logic.
- * The ServerConnectionHandler receives data send from the client as well as sends data to the client.
- * <p>
- * The ServeConnectionHandler offers following functionality:
- * <p>
- * Evaluating connection attempts from a client by:
- * 1. Checks if Username is valid (Not used)
- * 2. Saves Username in {@link ServerConnectionHandler#userName}
- * 3. Saves the connection in the {@link ServerConnectionHandler#connectionRegistry}
- * <p>
- * Processes disconnections from a client by:
- * 1. Removing the connection from the {@link ServerConnectionHandler#connectionRegistry}
- * 2. Terminates the socket by calling {@link NetworkHandler.NetworkConnection#close()}
- * <p>
- * Process Messages send from a client by:
- * 1. Evaluating the receiver by differentiating between broadcast or unicast.
- * 2. Sending the message accordingly.
- * <p>
- * To use this class, start a new instance and start it in a thread.
- * To constructor needs following parameter:
- * 1. {@link ch.zhaw.pm2.multichat.protocol.NetworkHandler.NetworkConnection} representing the socket connection between server and client
- * 2. {@link Map<String,ServerConnectionHandler>} registry to check for all active connections
- * 3. {@link ReentrantLock @link Condition} to lock server thread to evaluate connection.
- */
-public class ServerConnectionHandler extends ConnectionHandler implements Runnable {
+
+public class ServerConnectionHandler extends ConnectionHandler implements Runnable{
     private static final AtomicInteger connectionCounter = new AtomicInteger(0);
     private final int connectionId = connectionCounter.incrementAndGet();
-    private final Map<String, ServerConnectionHandler> connectionRegistry;
+    private final Map<String,ServerConnectionHandler> connectionRegistry;
 
-    private String userName = "Anonymous-" + connectionId;
+    private ReentrantLock mutex;
+
+    private Condition nameComplete;
+
+    private String userName = "Anonymous-"+connectionId;
     private State state = NEW;
 
-    /**
-     * Called when runnable gets started in a thread.
-     */
     @Override
     public void run() {
         startReceiving();
     }
 
-    /**
-     * Constructor to initialize the connection
-     *
-     * @param connection representing the socket connection between server and client
-     * @param registry   map containing all active connections between server and clients
-     */
     public ServerConnectionHandler(NetworkHandler.NetworkConnection<String> connection,
-                                   Map<String, ServerConnectionHandler> registry) {
+                                   Map<String,ServerConnectionHandler> registry, ReentrantLock mutex, Condition nameComplete) {
         super();
         setConnection(connection);
         Objects.requireNonNull(connection, "Connection must not be null");
         Objects.requireNonNull(registry, "Registry must not be null");
         this.connectionRegistry = registry;
+        this.mutex = mutex;
+        this.nameComplete = nameComplete;
+    }
+
+    public String getUserName() {
+        return this.userName;
+    }
+
+    public State getState() {
+        return state;
     }
 
-    /**
-     * These methods runs in a while-loop as long as the socket between server and client is available
-     * and the connection State is not ERROR.
-     */
     private void startReceiving() {
-        System.out.println("Starting Connection Handler for new User");
-        try {
-            System.out.println("Start receiving data...");
-            while (getConnection().isAvailable() && !(state == ERROR)) {
-                Message data = getConnection().receive();
-                processData(data);
+            System.out.println("Starting Connection Handler for new User");
+            try {
+                System.out.println("Start receiving data...");
+                while (getConnection().isAvailable() && !(state == ERROR)) {
+                    String data = getConnection().receive();
+                    processData(data);
+                }
+                System.out.println("Stopped recieving data");
+            } catch (SocketException e) {
+                System.out.println("Connection terminated locally");
+                connectionRegistry.remove(userName);
+                System.out.println("Unregistered because client connection terminated: " + userName + " " + e.getMessage());
+            } catch (EOFException e) {
+                System.out.println("Connection terminated by remote");
+                connectionRegistry.remove(userName);
+                System.out.println("Unregistered because client connection terminated: " + userName + " " + e.getMessage());
+            } catch (IOException e) {
+                System.err.println("Communication error: " + e);
+            } catch (ClassNotFoundException e) {
+                System.err.println("Received object of unknown type: " + e.getMessage());
             }
-            System.out.println("Stopped receiving data");
-        } catch (SocketException e) {
-            System.out.println("Connection terminated locally");
-            connectionRegistry.remove(userName);
-            System.out.println("Unregistered because client connection terminated: " + userName + " " + e.getMessage());
-        } catch (EOFException e) {
-            System.out.println("Connection terminated by remote");
-            connectionRegistry.remove(userName);
-            System.out.println("Unregistered because client connection terminated: " + userName + " " + e.getMessage());
-        } catch (IOException e) {
-            System.err.println("Communication error: " + e);
-        } catch (ClassNotFoundException e) {
-            System.err.println("Received object of unknown type: " + e.getMessage());
-        }
         if (state == ERROR) {
             System.out.println("Stopping Connection Handler for Rejected Client");
         } else {
@@ -108,9 +84,6 @@ public class ServerConnectionHandler extends ConnectionHandler implements Runnab
 
     }
 
-    /**
-     * This method will call {@link NetworkHandler.NetworkConnection#close()} to close the Socket.
-     */
     private void stopReceiving() {
         System.out.println("Closing Connection Handler for " + userName);
         try {
@@ -118,115 +91,123 @@ public class ServerConnectionHandler extends ConnectionHandler implements Runnab
             getConnection().close();
             System.out.println("Stopped receiving data.");
         } catch (IOException e) {
-            System.err.println("Failed to close connection." + e.getMessage());
+            System.err.println("Failed to close connection." + e);
         }
         System.out.println("Closed Connection Handler for " + userName);
     }
 
-    /**
-     * This method gets called when socket receives data. The method checks for the data type and reacts accordingly
-     * If data type:
-     * 1. Connect => checks if username is valid. if valid sends response to client with confirmation.
-     * If username not valid quits connection by changing status to ERROR.
-     * 2. Confirm => Server should not receive this kind of message. STDOUT informs about it.
-     * 3. Disconnect => Disconnects connection by removing connection from registry and calling method to terminate socket.
-     * 4. Message => Checks if broadcast or unicast. Sends data accordingly
-     * 5. Error => STDERR message
-     *
-     * @param data received by the server
-     */
-    private void processData(Message data) {
+    private void processData(String data)  {
         try {
-            // dispatch operation based on type parameter
-            if (data.getType() == DATA_TYPE.DATA_TYPE_CONNECT) {
-                caseConnect(data);
-            } else if (data.getType() == DATA_TYPE.DATA_TYPE_CONFIRM) {
-                System.out.println("Not expecting to receive a CONFIRM request from client");
-            } else if (data.getType() == DATA_TYPE.DATA_TYPE_DISCONNECT) {
-                caseDisconnect();
-            } else if (data.getType() == DATA_TYPE.DATA_TYPE_MESSAGE) {
-                caseMessage(data);
-            } else if (data.getType() == DATA_TYPE.DATA_TYPE_ERROR) {
-                System.err.println("Received error from client (" + data.getSender() + "): " + data.getText());
+            // parse data content
+            Scanner scanner = new Scanner(data);
+            String sender = null;
+            String reciever = null;
+            String type = null;
+            String payload = null;
+            if (scanner.hasNextLine()) {
+                sender = scanner.nextLine();
             } else {
-                System.err.println("Unknown data type received: " + data.getType());
+                throw new ChatProtocolException("No Sender found");
+            }
+            if (scanner.hasNextLine()) {
+                reciever = scanner.nextLine();
+            } else {
+                throw new ChatProtocolException("No Reciever found");
+            }
+            if (scanner.hasNextLine()) {
+                type = scanner.nextLine();
+            } else {
+                throw new ChatProtocolException("No Type found");
+            }
+            if (scanner.hasNextLine()) {
+                payload = scanner.nextLine();
+            }
+
+            // dispatch operation based on type parameter
+            if (type.equals(getDataTypeConnect())) {
+                if (this.state != NEW) throw new ChatProtocolException("Illegal state for connect request: " + state);
+                if (sender == null || sender.isBlank()) sender = this.userName;
+                if (connectionRegistry.containsKey(sender)) {
+                    mutex.lock();
+                    try {
+                        state = ERROR;
+                        nameComplete.signal();
+                    }
+                    finally {
+                        mutex.unlock();
+                    }
+                    throw new ChatProtocolException("User name already taken: " + sender);
+                }
+                mutex.lock();
+                try {
+                    this.userName = sender;
+                    nameComplete.signal();
+                }
+                finally {
+                    mutex.unlock();
+                }
+                connectionRegistry.put(userName, this);
+                sendData(USER_NONE, userName, getDataTypeConfirm(), "Registration successfull for " + userName);
+                this.state = CONNECTED;
+            } else if (type.equals(getDataTypeConfirm())) {
+                System.out.println("Not expecting to receive a CONFIRM request from client");
+            } else if (type.equals(getDataTypeDisconnect())) {
+                if (state == DISCONNECTED)
+                    throw new ChatProtocolException("Illegal state for disconnect request: " + state);
+                if (state == CONNECTED) {
+                    connectionRegistry.remove(this.userName);
+                }
+                sendData(USER_NONE, userName, getDataTypeConfirm(), "Confirm disconnect of " + userName);
+                this.state = DISCONNECTED;
+                this.stopReceiving();
+            } else if (type.equals(getDataTypeMessage())) {
+                if (state != CONNECTED) throw new ChatProtocolException("Illegal state for message request: " + state);
+                if (USER_ALL.equals(reciever)) {
+                    for (ServerConnectionHandler handler : connectionRegistry.values()) {
+                        handler.sendData(sender, reciever, type, payload);
+                    }
+                } else {
+                    ServerConnectionHandler handler = connectionRegistry.get(reciever);
+                    if (handler != null) {
+                        handler.sendData(sender, reciever, type, payload);
+                        if(!reciever.equals(sender)){
+                            sendData(sender, reciever, type, payload); //send message to sender if it's a direct message and sender is not receiver.
+                        }
+                    } else {
+                        this.sendData(USER_NONE, userName, getDataTypeError(), "Unknown User: " + reciever);
+                    }
+                }
+            } else if (type.equals(getDataTypeError())) {
+                System.err.println("Received error from client (" + sender + "): " + payload);
+            } else {
+                System.err.println("Unknown data type received: " + type);
 
             }
-        } catch (ChatProtocolException e) {
+        } catch(ChatProtocolException e) {
             System.out.println("Error while processing data " + e.getMessage());
             sendData(USER_NONE, userName, getDataTypeError(), e.getMessage());
         }
     }
 
-    /**
-     * This method is called by method {@link ServerConnectionHandler#processData(Message)}
-     * Checks if username is valid. if valid sends response to client with confirmation.
-     *
-     * @param data sent
-     * @throws ChatProtocolException if username not valid
-     */
-    private void caseConnect(Message data) throws ChatProtocolException {
-        if (this.state != NEW) throw new ChatProtocolException("Illegal state for connect request: " + state);
-        //if username not valid
-        if (connectionRegistry.containsKey(data.getSender())) {
-            state = ERROR;
-            System.out.println(String.format("Connecting failed for new Client with IP:Port <%s:%d>.\nReason: Name already taken.",
-                    getConnection().getRemoteHost(),
-                    getConnection().getRemotePort()));
-            throw new ChatProtocolException("User name already taken: " + data.getSender());
-        }
-        //if username valid
-        if (!data.getSender().isBlank()) {
-            this.userName = data.getSender();
-        }
-        connectionRegistry.put(userName, this);
-        sendData(USER_NONE, userName, getDataTypeConfirm(), "Registration successful for " + userName);
-        this.state = CONNECTED;
-        System.out.println(String.format("Connected new Client %s with IP:Port <%s:%d>",
-                userName,
-                getConnection().getRemoteHost(),
-                getConnection().getRemotePort()));
-    }
 
-    /**
-     * This method is called by method {@link ServerConnectionHandler#processData(Message)}
-     * Disconnects connection by removing connection from registry and calling method {@link ServerConnectionHandler#stopReceiving()} to terminate socket.
-     *
-     * @throws ChatProtocolException if state already DISCONNECTED.
-     */
-    private void caseDisconnect() throws ChatProtocolException {
-        if (state == DISCONNECTED)
-            throw new ChatProtocolException("Illegal state for disconnect request: " + state);
-        if (state == CONNECTED) {
-            connectionRegistry.remove(this.userName);
-        }
-        sendData(USER_NONE, userName, getDataTypeConfirm(), "Confirm disconnect of " + userName);
-        this.state = DISCONNECTED;
-        this.stopReceiving();
-    }
 
-    /**
-     * This method is called by method {@link ServerConnectionHandler#processData(Message)}
-     * Checks if broadcast or unicast. Sends data accordingly
-     *
-     * @param data to transmit
-     * @throws ChatProtocolException if state not equal to CONNECT
-     */
-    private void caseMessage(Message data) throws ChatProtocolException {
-        if (state != CONNECTED) throw new ChatProtocolException("Illegal state for message request: " + state);
-        if (USER_ALL.equals(data.getReceiver())) {
-            for (ServerConnectionHandler handler : connectionRegistry.values()) {
-                handler.sendData(data.getSender(), data.getReceiver(), data.getType(), data.getText());
-            }
-        } else {
-            ServerConnectionHandler handler = connectionRegistry.get(data.getReceiver());
-            if (handler != null) {
-                handler.sendData(data.getSender(), data.getReceiver(), data.getType(), data.getText());
-                if (!data.getReceiver().equals(data.getSender())) {
-                    sendData(data.getSender(), data.getReceiver(), data.getType(), data.getText()); //send message to sender if it's a direct message and sender is not receiver.
-                }
-            } else {
-                this.sendData(USER_NONE, userName, getDataTypeError(), "Unknown User: " + data.getReceiver());
+    private void sendData(String sender, String receiver, String type, String payload) {
+        if (getConnection().isAvailable()) {
+            new StringBuilder();
+            String data = new StringBuilder()
+                .append(sender+"\n")
+                .append(receiver+"\n")
+                .append(type+"\n")
+                .append(payload+"\n")
+                .toString();
+            try {
+                getConnection().send(data);
+            } catch (SocketException e) {
+                System.out.println("Connection closed: " + e.getMessage());
+            } catch (EOFException e) {
+                System.out.println("Connection terminated by remote");
+            } catch(IOException e) {
+                System.out.println("Communication error: " + e.getMessage());
             }
         }
     }