Cliente de Chat en Windows Phone 7.5 - Sockets

Cliente de Chat en Windows Phone 7.5 - Sockets

Español | Online - Código | Autor: Juan Segura | Publicación: 2013 | Pass:www.detodoprogramacion.org

Descripción:
En el primer artículo de esta serie, explicamos, de forma muy básica, que es un socket y la implementación que se ha realizado en Windows Phone 7.5. En esta segunda parte, veremos cómo crear el cliente del ejemplo que mostramos al final de ese primer artículo.

1. Esquema de la solución
Para esta serie de artículos, crearemos un cliente para Windows Phone 7.5 y un servidor para Windows Vista o superior utilizando WPF.
El siguiente esquema representa el funcionamiento de un servidor y dos clientes de chat:

a) Flujo de trabajo
En el esquema podemos apreciar el flujo de trabajo de la solución que nos ocupa.

1. Iniciamos el servidor.
2. Una vez iniciado el servidor, el cliente realiza una petición de conexión.
3. Si esta petición se completa, el cliente envía un mensaje de conexión.
4. A partir de aquí el cliente puede recibir o enviar datos al servidor.
5. Cuando el servidor recibe una petición de conexión, la acepta y lo añade a una lista de clientes conectados.
6. Cuando el servidor recibe datos desde alguno de los clientes, el servidor los reenvía a todos los clientes conectados, incluido el cliente que ha enviado el mensaje (aunque no sea necesario, es una forma de comprobar el correcto funcionamiento con un solo cliente).

b) Solución de ejemplo
La solución de ejemplo completa “ChatTest”, la podemos descargar desde www.duefectucorp.com/programacion/ChatTest.zip

En la imagen siguiente podemos ver la solución completa, tal como nos lo muestra el explorador de soluciones de Visual Studio:

2. El cliente de Chat
En este artículo vamos a ver cómo crear un cliente de Chat para Windows Phone 7.5. Para ello, trabajaremos con el proyecto "ChatTest.WP75".

a) MainPage
La “MainPage” implementa un interface de usuario muy básico, donde tenemos dos campos de texto, donde indicar la dirección IP y el puerto del servidor al que queremos conectar, y un botón para “Conectar” y otro para “Cerrar”.

Más abajo, un campo de texto nos permite introducir el texto que deseamos enviar al chat, acción que se realiza al pulsar el botón “Enviar”.

Por último, un objeto ListBox nos sirve de historial del chat, donde se nos informará de los procesos que realiza el cliente, además de los mensajes recibidos desde el servidor.

Esta “MainPage” no realiza ninguna acción directa sobre los sockets, trabajo que dejamos a la clase “SocketClient”.

b) SocketClient
Esta clase implementa tres métodos públicos: “Conectar”, “Cerrar” y “Enviar”. Los datos recibidos los devuelve a través de un método delegado que se pasa al método “Conectar”.

c) Los Sockets en Windows Phone 7.5
La implementación de sockets en Windows Phone 7.5 es asíncrona, y se apoya en el objeto SocketAsyncEventArgs, que define algunos de los parámetros de la comunicación.

En los siguientes puntos, veremos como se ha implementado el cliente en la clase “SocketClient”.

- Como abrir un socket

El siguiente código es un extracto del método “Conectar”:
public void Conectar(string IP, int puerto, Action callBackConectado, Action callBackDatosRecibidos) { // Asignamos valor a las variables privadas this.callBackConectado = callBackConectado; this.callBackDatosRecibidos = callBackDatosRecibidos; this.puerto = puerto; // Asignamos la IP a un objeto IPAddress IPAddress ipAddress = IPAddress.Parse(IP); // Creamos el SocketAsyncEventArgs que utilizaremos para el envío de datos argsSend = new SocketAsyncEventArgs(); // IP y puerto del servidor argsSend.RemoteEndPoint = new IPEndPoint(ipAddress, puerto); // Asignamos el evento Completed argsSend.Completed += new EventHandler(argsSend_Completed); // Creamos un socket TCP socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // Intentamos conectarnos de forma asincrona bool completesAsynchronously = socket.ConnectAsync(argsSend); // Si se ha podido completar de forma sincrona, emulamos la conexión asincrona if (!completesAsynchronously) { argsSend_Completed(argsSend.ConnectSocket, argsSend); } }
En este ejemplo, utilizaremos un objeto del tipo “SocketAsyncEventArgs” para el envío de datos (argsSend) y otro para la recepción (argsRecv).

La propiedad “RemoteEndPoint” apunta al servidor al que queremos conectarnos, y el evento “Completed” se dispara cada vez que se completa una orden de conexión o envío de datos.

Un detalle a tener en cuenta, es el uso de métodos delegados en vez de eventos. Se puede implementar con eventos, sin problema, pero Silverlight no destruye los objetos si tienen un evento asociado, lo que nos hace tener que eliminar ese evento antes de destruirlo. Un delegado no tiene este problema, por esta razón lo utilizo en vez de utilizar eventos.

- Completando la conexión
El siguiente código muestra la implementación del método “argsSend_Completed”:
private void argsSend_Completed(object sender, SocketAsyncEventArgs e) { // Comprobar si hay un error if (e.SocketError != SocketError.Success) { // Si hay un error cerramos el socket Cerrar(); if (e.LastOperation == SocketAsyncOperation.Connect) { // Si el error es de conexión ejecutamos el método de conexión completada callBackConectado(false); } else { // En otro caso, ejecutamos el método de datos recibidos callBackDatosRecibidos("ERROR"); } } else { // Si la operación se ha completado correctamente, y es una conexión if (e.LastOperation == SocketAsyncOperation.Connect) { // Conectado correctamente, lo notificamos callBackConectado(true); // Enviamos algo al servidor Enviar("Se ha unido al chat"); // Iniciamos el proceso de escucha Escuchar(); } // La operación de envío no la procesamos en caso de éxito } }
En este método, lo primero que hacemos es comprobar si ha ocurrido un error. En caso de que la operación se haya completado correctamente, si se trata de una operación de conexión, ejecutamos el método delegado de datos recibidos (para notificar al interface de usuario del evento), y enviamos el texto “Se ha unido al chat” al servidor, e inmediatamente iniciamos el proceso de escucha.

Este mismo método se ejecuta al completarse una operación de envío de datos, pero en este caso, si se ha realizado con éxito, se ignora.

- Enviando datos

El método “Enviar”, implementa el envío de datos al servidor, y aquí podemos ver su código:
public bool Enviar(string datos) { try { // Convertimos la cadena de datos en un array de bytes byte[] bufer = Encoding.UTF8.GetBytes(datos); // Ajustamos el bufer de envío argsSend.SetBuffer(bufer, 0, bufer.Length); // Enviamos los datos con el SocketAsyncEventArgs de envío bool ret = socket.SendAsync(argsSend); // Devolvemos el resultado return ret; } catch { return false; } }
El primer paso es convertir la cadena de texto en un array de bytes, para ello utilizamos “Encoding.UTF8.GetBytes”, hay que tener en cuenta que la implementación de Windows Phone no admite ASCII, por lo que utilizamos UTF-8.

Una vez tenemos los datos en un array de bytes, lo asignamos al bufer del objeto “SocketAsyncEventArgs” de envío, y lo enviamos con un SendAsync.

- Escuchando
El método “Escuchar” se encarga de recoger los datos recibidos por el cliente, y notificarlo al interface de usuario a través del método delegado asignado en el constructor:
private void Escuchar() { // Si ya estamos escuchando, salimos if (escuchando) { return; } // Indicamos que estamos escuchando escuchando = true; // Si no existe el objeto SocketAsyncEventArgs de recepción lo creamos if (argsRecv == null) { // Creamos el objeto SocketAsyncEventArgs de recepción argsRecv = new SocketAsyncEventArgs(); // Asignamos el bufer argsRecv.SetBuffer(buffer, 0, buffer.Length); // Escuchamos en todas las IPs y el puerto indicado argsRecv.RemoteEndPoint = new IPEndPoint(IPAddress.Any, puerto); // Asignamos el evento Completed para la recepción argsRecv.Completed += new EventHandler(argsRecv_Completed); } // Ejecutamos la recepción de datos asincrona socket.ReceiveFromAsync(argsRecv); }
Vemos cómo se crea un nuevo objeto “SocketAsyncEventArgs”, que se utiliza exclusivamente para el envío de datos, y le asignamos un “RemoteEndPoint” y un bufer, que en este caso es de 1024 bytes.

Capturamos el evento “Completed” y empezamos la recepción asíncrona.

- Recibiendo datos
El método “argsRecv_Completed” se ejecuta cuando se reciben datos por el socket (desde el servidor):
private void argsRecv_Completed(object sender, SocketAsyncEventArgs e) { // Indicamos que se ha terminado la escucha escuchando = false; // Convertimos los datos recibidos en una cadena string datos = Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred); // Ejecutamos el método de datos recibidos callBackDatosRecibidos(datos); // Volvemos a escuchar Escuchar(); }
En este caso, convertimos el array de datos recibidos en una cadena, y lo enviamos al interface de usuario a través del método delegado correspondiente.

- Cerrar

Por último, para cerrar la conexión, se utiliza el método “Cerrar”, que cierra el socket y destruye los objetos que se han utilizado.
public bool Cerrar() { try { // Comprobamos si el socket existe if (socket != null) { // Si el socket está conectado, lo desconectamos if (socket.Connected) { socket.Shutdown(SocketShutdown.Both); } // Cerramos el socket y liberamos los recursos socket.Close(); socket.Dispose(); socket = null; // Si el objeto SocketAsyncEventArgs de envío existe, lo eliminamos if (argsSend != null) { argsSend.Completed -= new EventHandler(argsSend_Completed); argsSend.Dispose(); argsSend = null; } // Si el objeto SocketAsyncEventArgs de recepción existe, lo eliminamos if (argsRecv != null) { argsRecv.Completed -= new EventHandler(argsRecv_Completed); argsRecv.Dispose(); argsRecv = null; } } // Informamos del cierre correcto return true; } catch { return false; } }

4. Conclusiones
Como podemos ver, la implementación de Windows Phone 7.5 difiere de la de .Net de “escritorio”, y una de las mayores limitaciones es la no existencia del método “Bind”, o la propiedad “LocalEndPoint”.

Hay que tener en cuenta que podemos tener excepciones de comunicaciones en cualquier momento, por lo que hay que tratarlas adecuadamente.

En el próximo artículo veremos cómo implementar un servidor de chat, sirva como adelanto un pantallazo del servidor, y del emulador.