ChatServer.java

Go to the documentation of this file.

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;

/**
 *  Chat server principal class that listens on socket for new connections.
 *  It instantiates a new threaded client back-end for each new connection and keeps all
 *  such client connections in the list. Client back-end thread purges itself from the
 *  list after remote end is disconnected.
 *  
 *  @author Mikica B Kocic
 */
public class ChatServer extends Thread {

    /**
     *  Provides message presentation context to instance of <code>ChatServer</code>.
     */
    public interface Context
    {
        /**
         *  Logs message to log area
         *  
         *  @param str    message that will be logged
         */
        public abstract void logMessage( String str );

        /**
         *  Updates status message.
         *  
         *  @param str    new status message
         */
        public abstract void logStatus( String str );
    }

    //////////////////////////////////////////////////////////////////////////////////////

    /**
     *  Server identifier; concatenated host name with TCP port
     */
    private String serverID;
    
    /**
     *  TCP port that chat server listens for new connections 
     */
    private int port;

    /**
     *  Collection of active threaded chat clients (instances of 
     *  <code>ChatServerClient</code>).  
     */
    private ArrayList<ChatServerClient> clients;
    
    /**
     *  Indicates if thread is (or should be) running
     */
    private volatile boolean running;
    
    /**
     *  Event (call-back) context for the instance
     */
    private Context context;
    
    /**
     *  Creates instance of the chat server.
     *  
     *  @param port     TCP port to listen
     *  @param context  context where to log messages and send status updates
     */
    public ChatServer( int port, Context context )
    {
        this.clients  = new ArrayList<ChatServerClient> ();
        this.port     = port;
        this.context  = context;
        this.running  = true;
        this.serverID = "";
    }

    /**
     *  Get number of active client back-ends
     */
    public int getClientCount ()
    {
        synchronized( clients )
        {
            return clients.size ();
        }
    }

    /**
     *  Broadcasts message (terminated with new line) to all clients
     *  
     *  @param from    originator, if <code>null</code> means that system sends a message
     *  @param message textual message that should be broadcasted
     */
    public void broadcast( ChatServerClient from, String message )
    {
        if ( from == null ) { // Message from the system
            context.logMessage( message );
            message = "[System] :: " + message;
        }
        else {
            context.logMessage( "[" + from.getClientName() + "] " + message );
        }
        
        synchronized( clients )
        {
            for( ChatServerClient c: clients ) {
                c.send( message );
            }
        }
    }

    /**
     *  Responds to "wwhhoo" message. Broadcasts list of connected users
     *  to all connected users.
     */
    public void wwhhoo( ChatServerClient from )
    {
        context.logMessage( "[" + from.getClientName() + "] wwhhoo" );

        synchronized( clients )
        {
            for( ChatServerClient c: clients ) {
                String message = "WWHHOO: " + c.getClientName();
                for( ChatServerClient c2: clients ) {
                    c2.send( message );
                }
            }
        }
    }

    /**
     *  Logs messages from Eliza sent to client
     *  
     *  @param message textual message that should be broadcasted
     *  @param to      client
     */
    public void logEliza( String message, ChatServerClient to )
    {
        context.logMessage( "Eliza -> [" + to.getClientName() + "] " + message );
    }

    /**
     *  Adds new client's back-end to the list of back-ends
     */
    public void addClient( Socket clientSocket )
    {
        int n; // will contain number of client after removal, used for status message

        synchronized( clients )
        {
            ChatServerClient client = new ChatServerClient( this, clientSocket );

            clients.add( client );
            client.start ();
            n = clients.size ();
        }

        /* update context status message appropriately
         */
        context.logStatus( serverID +
                ( n == 0 ? ", idle" : 
                  n == 1 ? ", 1 client active " 
                         : ", " + n + " clients active" )
              );
    }
    
    /**
     *  Removes existing client's back-end from the list of back-ends
     */
    public void removeClient( ChatServerClient cli )
    {
        int n; // will contain number of client after removal, used for status message
        
        synchronized( clients )
        {
            clients.remove( cli );
            n = clients.size ();
        }

        /* update context status message appropriately
         */
        context.logStatus( serverID +
                  ( n == 0 ? ", idle" : 
                    n == 1 ? ", 1 client active " 
                           : ", " + n + " clients active" )
                );
    }
    
    /**
     *  Listens on socket for new connections. After accepting new connection,  
     *  instantiates a new threaded client back-end for that connection.
     */
    @Override
    public void run ()
    {
        ServerSocket socket = null;
        
        /* Create socket
         */
        try
        {
            socket = new ServerSocket( this.port );
        }
        catch( IOException e )
        {
            context.logMessage( e.toString () );
            running = false;
        }
        
        /* Setup server ID, if we have socket...
         */
        if ( running )
        {
            try {
                serverID = InetAddress.getLocalHost().getHostName ()
                         + ":" + socket.getLocalPort ();
            } catch( UnknownHostException e ) {
                serverID = "unknown:" + socket.getLocalPort ();
            }
            context.logStatus( serverID + ", idle" );
            context.logMessage( "Server at " + serverID 
                                + " ready to accept new clients..." );
        }

        /* Listen for new connections, accept clients and add them to the
         * list of back-ends.
         */
        while( running )
        {
            try
            {
                addClient( socket.accept () );
            }
            catch ( IOException e )
            {
                context.logMessage( e.toString () );
                running = false;
            }
        }
        
        /* Inform parent that we are dead. Note that <code>", dead"</code> will
         * trigger also change in color of the log area background.
         */
        context.logStatus( serverID + ":" + port + ", dead" );
        context.logMessage( "Done." );
    }
}