SecureClient.java

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.Exception;
import java.lang.Runnable;
import java.lang.Thread;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Observable;
import java.util.Observer;
import java.util.ArrayList;
import java.io.Serializable;
import java.net.InetAddress;
import java.io.IOException;
import java.net.UnknownHostException;

 enum MessageType {
    MESSAGE, DISCONNECT, GETCLIENTS
};


class SecureClient extends Observable implements Runnable {
    Socket socket;
    private ObjectInputStream inputStream;
    private ObjectOutputStream outputStream;
    ArrayList<InetAddress> availableClients;
    private final int timeout = 1000;


    public SecureClient(int port,InetAddress serverIp) throws ServerUnavailableException {
        try {
            this.socket = new Socket(serverIp,port);
            this.inputStream = new ObjectInputStream(socket.getInputStream());
            this.outputStream = new ObjectOutputStream(socket.getOutputStream());
            this.availableClients = new ArrayList<InetAddress>();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //socket.connect(new InetSocketAddress(serverIp,port),timeout);

        if(!socket.isConnected()) {
            throw new ServerUnavailableException("Server connection request timed out ("+timeout+"ms)");
        }

        try {
            this.run();
        } catch(Exception e) {
            System.out.println(e.getStackTrace());
        }

    }

    public void sendMessage(String message,MessageType messageType,InetAddress receiver) throws Exception {
        SecureMessage sMessage = new SecureMessage(message,messageType,receiver,socket.getInetAddress());
        outputStream.writeObject(sMessage);
    }

    public void disconnect(String reason) {
        try {
            sendMessage(reason,MessageType.DISCONNECT,InetAddress.getByName("127.0.0.1"));
            socket.close();
        } catch(Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true) {
            SecureMessage fromServer = null;
            try {
                fromServer = (SecureMessage) inputStream.readObject();
            } catch (Exception e) {
                System.out.println(e.getStackTrace());
            }
            if (fromServer != null) {
                setChanged();
                notifyObservers(fromServer);
            }
        }
    }


}


 class ServerUnavailableException extends Exception {
    private static final long serialVersionUID = 42L;
    public ServerUnavailableException() {
        super();
    }
  public ServerUnavailableException(String message) {
        super(message);
    }
  public ServerUnavailableException(String message, Throwable cause) {
        super(message, cause);
    }
  public ServerUnavailableException(Throwable cause) {
        super(cause);
    }

}

 class SecureMessage implements Serializable {
    private static final long serialVersionUID = 42L;
    private String message;
    private InetAddress receiver;
    private InetAddress sender;
    private MessageType type; // can be MESSAGE, DISCONNECT, GETCLIENTS

    /**
     * Wrapper for any message that is sent between clients. The object gets serialized and sent through tcp.
     * @param   The message as a string object
     * @param   The InetAddress of the receiver
     * @param   The InetAddress of the sender
     */
    public SecureMessage(String message,MessageType messageType, InetAddress receiver, InetAddress sender) {
        this.message = message;
        this.type = messageType;
        this.receiver = receiver;
        this.sender = sender;
    }

    /**
     * Returns the message
     * @return A message
     */
    public String getMessage() {
        return this.message;
    }

    /**
     * Returns the receiver of the message
     * @return A InetAddress representing the receiver
     */
    public InetAddress getReceiver() {
        return this.receiver;
    }

    /**
     * Returns the sender of the message
     * @return A InetAddress representing the sender
     */
    public InetAddress getSender() {
        return this.sender;
    }
}


 class ClientHandler extends Observable implements Observer{

    private ArrayList<SecureClient> clients = new ArrayList<SecureClient>();
    private Observer owner;

    public ClientHandler(Observer owner) {
        this.owner = owner;
    }

    public void update(Observable o, Object message) {
        if(o instanceof SecureClient) {
            setChanged();
            notifyObservers(message);
        }
    }

    public void addClient(SecureClient newClient) {
        newClient.addObserver(this);
        clients.add(newClient);
    }

    public void disconnectClient(SecureClient client,String reason) {
        clients.remove(client);
        client.disconnect(reason);
    }

}