ChatClient.java

Go to the documentation of this file.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 *  Threaded chat client.
 *
 *  @author Mikica B Kocic
 */
public class ChatClient extends Thread 
{
    /**
     *  Provides message presentation context to instance of <code>ChatClient</code>.
     */
    public interface Context
    {
        /**
         *  Logs messages formated with HTML tags
         *  
         *  @param str    message that will be logged
         */
        public abstract void logMessage( String str );

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

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

    /**
     *  Host name or IP address of the remote chat server 
     */
    private String host;
    
    /**
     *  TCP port where to connect to on remote chat server 
     */
    private int port;

    /**
     *  Output stream to remote server
     */
    private PrintWriter out;
    
    /**
     *  Instance of the TCP socket to chat server.
     */
    private Socket socket;
    
    /**
     *  Indicates if thread is (or should be) running
     */
    private volatile boolean running;
    
    /**
     *  Event (call-back) context for the instance
     */
    private Context context;

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

    /**
     *  Creates new instance of <code>ChatClient</code> that posts messages 
     *  to specified <code>Context</code>. 
     *  
     *  @param host     host name or ip address of the chat server
     *  @param port     tcp port
     *  @param context  where to log messages (also error and info messages)
     */
    public ChatClient( String host, int port, Context context )
    {
        assert( context != null );

        this.socket   = null;
        this.host     = host;
        this.port     = port;
        this.context  = context;
        this.out      = null;   
        this.running  = false;
    }

    /**
     * Starts the thread.
     */
    @Override
    public void start ()
    {
        if ( isAlive () || running ) {
            return;  // Allow only one thread per instance
        }

        running = true;
        super.start ();
    }

    /**
     *  Sends message (appended with new-line) to chat server
     *  
     *  @param message   message to be sent
     */
    public void send( String message )
    {
        synchronized( this )
        {
            if ( out == null || message == null ) {
                return;
            }
            
            out.println( message );
            out.flush ();
        }
    }

    /**
     *  Sends message (appended with new-line) to chat server prefixed with userID
     *  
     *  @param message    message to be sent
     *  @param userId    user identifier
     */
    public void send( String message, String userId )
    {
        send( userId + " :: " + message );
    }

    /**
     *  Closes the connection gracefully
     */
    public void close ()
    {
        synchronized( this )
        {
            running = false;

            if ( socket != null && ! socket.isClosed () ) {
                try {
                    socket.close ();
                } catch( IOException e ) {
                    /* ignore */
                }
            }
        }
    }
    
    /**
     *  Escapes HTML reserved characters (as we are logging HTML tagged messages)
     */
    private static String EscapeHTML( String str )
    {
        return str.replaceAll( "&",  "&amp;"  ) 
                  .replaceAll( "<",  "&lt;"   )
                  .replaceAll( ">",  "&gt;"   ) 
                  .replaceAll( "\"", "&quot;" );
    }

    /**
     *  Reports an error message to log 
     */
    private void reportError( String str )
    {
        context.logMessage(
            "<code>" + now () 
                     + "&nbsp;&nbsp;<span style='color:red'>" 
                     + EscapeHTML( str ) 
                     + "</span></code><br/>"
            );
    }

    /**
     *  Reports an info message to log 
     */
    private void reportInfo( String str )
    {
        context.logMessage(
            "<code>" + now () 
                     + "&nbsp;&nbsp;<span style='color:green'>"
                     + EscapeHTML( str )
                     + "</span></code><br/>"
            );
    }

    /**
     *  Gets current time stamp
     *  
     *  @return time in ISO format 
     */
    private static String now ()
    {
        Calendar cal = Calendar.getInstance ();
        SimpleDateFormat sdf = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );
        return sdf.format( cal.getTime() );
    }

    /**
     *  Connects socket, then reads messages from server while <code>running</code> flag 
     *  is enabled. Finally, closes connection in graceful manner.
     */
    @Override
    public void run ()
    {
        reportInfo( "Connecting to " + host + ":" + port + "..." );
        context.logStatus( "Connecting to " + host + ":" + port + "..." );

        //////////////////////////////////////////////////////////////////////////////////
        /* Open connection
         */
        try
        {
            synchronized( this ) {
                socket = new Socket( host, port );
            }
        }
        catch( UnknownHostException e )
        {
            reportError( "'Unknown host' exception while creating socket" );
            reportError( e.toString () );
            running = false;
        }
        catch( IOException e )
        {
            reportError( "I/O exception while connecting" );
            reportError( e.toString () );
            running = false;
        }

        //////////////////////////////////////////////////////////////////////////////////
        /* Get input stream. Consider input characters UTF-8 encoded.
         * TODO: It would be nice to have this as a parameter.
         */
        InputStreamReader reader = null;
        try
        {
            if ( socket != null ) {
                reader = new InputStreamReader( socket.getInputStream (), "utf-8" );
            }
        }
        catch( IOException e )
        {
            reportError( "I/O exception while getting input stream" );
            reportError( e.toString () );
            running = false;
            reader = null;
        }
        
        //////////////////////////////////////////////////////////////////////////////////
        /* Get output stream. Encode our character strings as UTF-8.
         */
        try 
        {
            if ( socket != null ) {
                out = new PrintWriter(
                        new OutputStreamWriter( socket.getOutputStream(), "utf-8" ),
                        /*autoflush*/ true );
            }
        }
        catch( IOException e )
        {
            reportError( "I/O exception while getting output stream" );
            reportError( e.toString () );
            running = false;
            out = null;
        }

        //////////////////////////////////////////////////////////////////////////////////
        /* Finally connected... (if running == true survived until here)
         */
        BufferedReader in = null;
        if ( running ) {
            context.logStatus( "Connected to " + host + ":" + port );
            reportInfo( "Connected; type a message, then press Enter or click 'Send'" );
            reportInfo( "All your messages will be prefixed with your ID..." );
            in = new BufferedReader( reader );
        }
        
        //////////////////////////////////////////////////////////////////////////////////
        /* Read messages from the socket and dump them on log area
         */
        while( running )
        {
            try
            {
                String message = in.readLine ();

                /* Parse input with syntax: [ [ <userId> ] ":: " ] <message>
                 * where default userId is [Anonymous].
                 */
                String[] parts = message.split( ":: ", 2 );
                String userId = "[Anonymous]";
                
                if ( message.startsWith( "WWHHOO: " ) ) {
                    userId = "WWHHOO";
                    message = message.substring( 8 );
                } else if ( parts.length == 0 ) {
                    message = parts[0];
                } else if ( parts[0].trim().length () == 0 && parts.length >= 2 ) {
                    message = parts[1];
                } else if ( parts.length >= 2 ) {
                    userId  = parts[0].trim ();
                    message = parts[1];
                } else {
                    message = parts[0];
                }

                context.logMessage(
                    "<code>" + now () 
                             + "&nbsp;&nbsp;" 
                             + EscapeHTML( userId ).trim () 
                             + ": <span style='"
                             + ( userId.equals( "Eliza" ) ? "color:red" : "color:blue" )
                             + "'>"
                             + EscapeHTML( message ).trim ()
                             + "</span></code><br/>"
                    );
            }
            catch( IOException e )
            {
                reportError( "Connection lost!" );
                reportError( e.toString () );
                running = false;
            }
        }

        reportInfo( "Closing connection " + host + ":" + port + "..." );

        //////////////////////////////////////////////////////////////////////////////////
        /* Close connection gracefully
         */
        try
        {
            if ( out != null ) {
                out.close ();
            }
            if ( in != null ) {
                in.close ();
            }
            synchronized( this )
            {
                if ( socket != null && ! socket.isClosed () ) {
                    socket.close ();
                }
            }
        }
        catch( IOException e )
        {
            reportError( "I/O exception while closing connection" );
            reportError( e.toString () );
        }
        
        reportInfo( "Thread " + host + ":" + port + " completed." );
    }
}