AWT

1. (CHAT) Como ejercicio en este tema vamos a desarrollar una aplicación visual para  un chat. El motor de chat se hizo ya en el tema anterior, cuando se vio la comunicación por red y la entrada / salida. Aquí tenéis un ejemplo de motor hecho, por si no os dio tiempo a terminar el vuestro.

• En el paquete usuarios se tienen clases para el registro y la gestión de usuarios:
• La clase AccesoUsuarios es un interfaz, que deberá implementar cualquier clase que se quiera utilizar para gestionar los usuarios del chat.
• La clase AccesoFicheroUsuarios implementa la interfaz anterior para gestionar los usuarios guardando sus datos en un fichero, y leyendo del fichero dichos datos. El fichero en cuestión es datos\usuarios. Más adelante se gestionarán los usuarios por base de datos (con lo que habrá que hacer otra clase que implemente la interfaz y acceda a bases de datos en lugar de a ficheros)
• La clase LoginInvalidoException es una excepcion que se lanza cuando el login que introduce un usuario no es válido.
• En el paquete es hay clases básicas para el tratamiento de la entrada/salida:
• La clase ConexionSocket define la conexión genérica desde un cliente a un servidor
• La clase EntradaConsola permite leer lo que el usuario introduzca por el teclado
• En el paquete chat se tienen las clases base para el chat:
• La clase ClienteChat define el cuerpo de cada cliente que se conecte a un chat
• La clase ServidorChat será el servidor, que acepte las peticiones de los clientes y gestione las conexiones
• Finalmente, la clase EjemploChat es un ejemplo de cliente chat en modo texto, que muestra las opciones y permite conectar con un ServidorChat.

Se tienen unos scripts (BAT para Windows, SH para Linux) para poder compilar y ejecutar el ejemplo. Sólo hay que colocarse en el directorio donde estén y ejecutar el comando apropiado.

• El fichero compilar permite compilar todo el ejemplo

compilar		(Windows)
. ./compilar.sh		(Linux)

• El fichero servidor ejecuta el servidor de chat

servidor		(Windows)
. ./servidor.sh		(Linux)

• El fichero cliente ejecuta el cliente, pasándole como parámetro la dirección IP del servidor al que conectar.

cliente	<ip>		(Windows)
. ./cliente.sh <ip>	(Linux)

Ahora se trata de realizar un programa AplicChat para chatear en modo gráfico:

 

Tendrá 4 zonas al menos:

• Una zona donde indicar la dirección IP a la que conectar
• Una zona para poder registrar nuevos usuarios, o validar los datos de un usuario registrado que se quiera conectar (introducir su login y password)
• Una zona donde ver los mensajes que se van escribiendo (buffer de mensajes)
• Otra zona para poder enviar mensajes al chat

La clase sólo tiene el código para conectar a la dirección IP del servidor (sólo tiene los controles de la parte superior para conectar con la IP que se escriba en el cuadro de texto. Tendréis que modificar el código si utilizais vuestro propio motor de chat y es distinto al que se os da). 

Lo que haremos será construir el resto de la aplicación (lo que queda abajo). Todo el código lo tenéis que colocar en el método init(), puesto que luego en posteriores sesiones se convertirá esta aplicación en applet. Aparte podéis definir vuestros propios métodos si queréis (sin tocar el constructor ni el método main()).

Todo el sistema de comunicación cliente / servidor está hecho en el motor ejemplo, o en el ejercicio que se hizo en el tema anterior. Ahora simplemente hay que hacer que AplicChat haga lo mismo que el EjemploChat del ejemplo proporcionado.

a) Primero vamos a colocar los controles en la aplicación:

• Podemos cambiar el GridLayout donde están colocados los controles de la IP, y hacer que sea de 3 filas,  para que la segunda tenga el login y el botón de registrar (o validar) y la tercera el password y el botón de validar (o registrar):

panelSup.setLayout(new GridLayout(3, 3));

Para colocar  las dos filas que faltan, basta con replicar el código para la línea de conexión que hay (cambiando los nombres de las variables a los que nos interese), y definir el evento correspondiente para cada botón:

Label lblIP = new Label ("IP Servidor:");
txtIP = new TextField();
panelSup.add(lblIP);
panelSup.add(txtIP);

Button btnConectar = new Button ("Conectar");
btnConectar.addActionListener(new ActionListener()
{
	public void actionPerformed(ActionEvent e)
	{
		...// Codigo que se necesite
	}
});
panelSup.add(btnConectar);

• Después colocamos un TextArea en la zona central, donde se mostrarán los datos que se reciban del servidor. Para construirlo podemos utilizar un constructor por defecto, pero en este caso cuando el texto crezca más que el cuadro no lo podremos ver. Hay que añadirle barras de desplazamiento, y para eso se utiliza un constructor con 4 parámetros:

  TextArea(String texto, int filas, int columnas, int barras)

  donde barras puede ser, la constante TextArea.SCROLLBARS_BOTH, que indica que se ponga tanto la barra horizontal como la vertical:

TextArea txtBuffer = new TextArea("", 5, 5, 
		     TextArea.SCROLLBARS_BOTH);
add(txtBuffer, BorderLayout.CENTER);

• Finalmente podemos crear un GridLayout para la zona Sur (de forma parecida al que se ha hecho para la parte superior), de 2 filas y 1 columna, y añadirle en una celda el cuadro de texto (TextField) para enviar mensajes, y en otra el botón para enviar.

Panel panelInf = new Panel();
panelInf.setLayout(new GridLayout(2, 1));
		
TextField txtMensaje = new TextField();
panelInf.add(txtMensaje);
		
Button btnEnviar = new Button("Enviar");
btnEnviar.addActionListener(new ActionListener()
{
	public void actionPerformed(ActionEvent e)
	{
		... // Codigo que se necesite
	}
});
panelInf.add(btnEnviar);
		
add(panelInf, BorderLayout.SOUTH);		

b) Una vez tenemos todos los controles colocados (compilad y ejecutad para ver que se colocan como queríais), añadimos los eventos sobre los botones:

• Que al REGISTRAR un nuevo usuario se compruebe si los datos no son correctos (utilizando los métodos del motor de chat construido previamente, y capturando las excepciones adecuadas), y muestre en el cuadro de texto central un mensaje de error si no son datos válidos.

try {
	chat.registraUsuario(txtLogin.getText(), 
			     txtPassword.getText());
} catch(Exception ex) {
	txtBuffer.append("Error al registrar\n");
}

• Que al VALIDAR un usuario existente compruebe si los datos son correctos (utilizando los métodos de validación del motor de chat construido, y capturando las excepciones adecuadas), y muestre en el cuadro de texto central un mensaje de error si no son datos válidos. Al validar correctamente, se deben empezar a tomar los datos del servidor periódicamente, actualizando el cuadro de texto central con los mensajes que vayan llegando:
  • Se puede utilizar un hilo para tomar continuamente los datos. Para ello, podemos hacer que la clase AplicChat implemente Runnable:

  public class AplicChat 
  extends Frame 
  implements Runnable
  ...

Le definimos un campo de tipo Thread (fuera del constructor):

Thread t = new Thread(this);

Finalmente, definimos el método run() que se encargará de ir tomando continuamente los datos del servidor. Podemos hacer que los saque al cuadro de texto central llamando al método append(...) del mismo, para no borrar el texto previo:

public void run() 
{		
   String msg = null;
   while((msg=chat.recibeMensaje())!=null) 
   {
	txtBuffer.append(msg + "\n");
   }
}

En el evento del botón validar sólo habrá que iniciar el hilo si se valida correctamente:

try {
   chat.loginUsuario(txtLogin.getText(), 
		     txtPassword.getText());
   t.start();
} catch(Exception ex) {
   txtBuffer.append("Error al validar\n");
}

• ENVIAR un mensaje es simplemente enviar el contenido del cuadro de texto del mensaje al servidor:

chat.enviaMensaje(txtMensaje.getText());

Una vez esté todo colocado y compilado, a la hora de probarlo simplemente tenemos que ejecutar esta aplicación en lugar del EjemploChat o el programa ejemplo que estuviéramos utilizando. El servidor no cambia.

Para entregar: Debéis entregar un ZIP e3_1.zip con:

• La aplicación de chat, añadiéndole el fichero AplicChat.java construido.