Y tal como hicimos en el caso de SOAP, vamos a crear una aplicación de ejemplo que llame a las distintas funciones de nuestro servicio web. En este caso la aplicación se compondrá de 5 botones, uno por cada una de las acciones que hemos implementado en el servicio web (insertar, actualizar, eliminar, recuperar un cliente, y listar todos los clientes).

A diferencia del caso de SOAP, en esta ocasión no vamos a utilizar ninguna librería externa para acceder al servicio web, ya que Android incluye todo lo necesario para realizar la conexión y llamada a los métodos del servicio, y tratamiento de resultados en formato JSON.

Como ya hemos comentado, al trabajar con servicios web de tipo REST, las llamadas al servicio no se harán a través de una única URL, sino que se determinará la acción a realizar según la URL accedida y la acción HTTP utilizada para realizar la petición (GET, POST, PUT o DELETE). En los siguientes apartados veremos uno a uno la implementación de estos botones.

Insertar un nuevo cliente

Como ya comentamos en el artículo anterior, la inserción de un nuevo cliente la realizaremos a través de la siguiente URL:

http://10.0.2.2:2731/Api/Clientes/Cliente

Utilizaremos la acción http POST y tendremos que incluir en la petición un objeto en formato JSON que contenga los datos del nuevo cliente (tan sólo Nombre y Teléfono, ya que el ID se calculará automáticamente). El formato de este objeto de entrada será análogo al siguiente:

{Nombre:”cccc”, Telefono:12345678}

Pues bien, para conseguir esto comenzaremos por crear un nuevo objeto HttpClient, que será el encargado de realizar la comunicación HTTP con el servidor a partir de los datos que nosotros le proporcionemos. Tras esto crearemos la petición POST creando un nuevo objeto HttpPost e indicando la URL de llamada al servicio. Modificaremos mediante setHeader() el atributo http content-type para indicar que el formato de los datos que utilizaremos en la comunicación, que como ya indicamos será JSON (cuyo MIME-Type correspondiente es “application/json“).

HttpClient httpClient = new DefaultHttpClient();

HttpPost post =
    new HttpPost("http://10.0.2.2:2731/Api/Clientes/Cliente");

post.setHeader("content-type", "application/json");

El siguiente paso será crear el objeto JSON a incluir con la petición, que deberá contener los datos del nuevo cliente a insertar. Para ello creamos un nuevo objeto JSONObject y le añadimos mediante el método put() los dos atributos necesarios (nombre y teléfono) con sus valores correspondientes, que los obtenemos de los cuadros de texto de la interfaz, llamados txtNombre y txtTelefono.

Por último asociaremos este objeto JSON a nuestra petición HTTP convirtiéndolo primero al tipo StringEntity e incluyéndolo finalmente en la petición mediante el método setEntity().

//Construimos el objeto cliente en formato JSON
JSONObject dato = new JSONObject();

dato.put("Nombre", txtNombre.getText().toString());
dato.put("Telefono", Integer.parseInt(txtTelefono.getText().toString()));

StringEntity entity = new StringEntity(dato.toString());
post.setEntity(entity);

Una vez creada nuestra petición HTTP y asociado el dato de entrada, tan sólo nos queda realizar la llamada al servicio mediante el método execute() del objeto HttpClient y recuperar el resultado mediante getEntity(). Este resultado lo recibimos en forma de objeto HttpEntity, pero lo podemos convertir fácilmente en una cadena de texto mediante el método estático EntityUtils.toString().

HttpResponse resp = httpClient.execute(post);
String respStr = EntityUtils.toString(resp.getEntity());

if(respStr.equals("true"))
	lblResultado.setText("Insertado OK.");

En nuestro caso, el método de inserción devuelve únicamente un valor booleano indicando si el registro se ha insertado correctamente en la base de datos, por lo que tan sólo tendremos que verificar el valor de este booleano (“true” o “false”) para conocer el resultado de la operación, que mostraremos en la interfaz en una etiqueta de texto llamada lblResultado.

Actualizar un cliente existente

La URL utilizada para la actualización de clientes será la misma que la anterior:

http://10.0.2.2:2731/Api/Clientes/Cliente

Pero en este caso, el objeto JSON a enviar como entrada deberá contener no sólo los nuevos valores de nombre y teléfono sino también el ID del cliente a actualizar, por lo que tendría una estructura análoga a la siguiente:

{Id:123, Nombre:”cccc”, Telefono:12345678}

Para actualizar el cliente procederemos de una forma muy similar a la ya comentada para la inserción, con las únicas diferencias de que en este caso la acción HTTP utilizada será PUT (objeto HttpPut) y que el objeto JSON de entrada tendrá el campo ID adicional.

HttpClient httpClient = new DefaultHttpClient();

HttpPut put = new HttpPut("http://10.0.2.2:2731/Api/Clientes/Cliente");
put.setHeader("content-type", "application/json");

try
{
	//Construimos el objeto cliente en formato JSON
	JSONObject dato = new JSONObject();

	dato.put("Id", Integer.parseInt(txtId.getText().toString()));
	dato.put("Nombre", txtNombre.getText().toString());
	dato.put("Telefono", Integer.parseInt(txtTelefono.getText().toString()));

	StringEntity entity = new StringEntity(dato.toString());
	put.setEntity(entity);

      	HttpResponse resp = httpClient.execute(put);
       	String respStr = EntityUtils.toString(resp.getEntity());

       	if(respStr.equals("true"))
       		lblResultado.setText("Actualizado OK.");
}
catch(Exception ex)
{
       	Log.e("ServicioRest","Error!", ex);
}

Eliminación de un cliente

La eliminación de un cliente la realizaremos a través de la URL siguiente:

http://10.0.2.2:2731/Api/Clientes/Cliente/id_cliente

donde id_cliente será el ID del cliente a eliminar. Además, utilizaremos la acción http DELETE (objeto HttpDelete) para identificar la operación que queremos realizar. En este caso no será necesario pasar ningún objeto de entrada junto con la petición, por lo que el código quedará aún más sencillo que los dos casos anteriores.

HttpClient httpClient = new DefaultHttpClient();

String id = txtId.getText().toString();

HttpDelete del =
	new HttpDelete("http://10.0.2.2:2731/Api/Clientes/Cliente/" + id);

del.setHeader("content-type", "application/json");

try
{
       	HttpResponse resp = httpClient.execute(del);
       	String respStr = EntityUtils.toString(resp.getEntity());

      	if(respStr.equals("true"))
       		lblResultado.setText("Eliminado OK.");
}
catch(Exception ex)
{
      	Log.e("ServicioRest","Error!", ex);
}

Como podéis ver, al principio del método obtenemos el ID del cliente desde la interfaz de la aplicación y lo concatenamos con la URL base para formar la URL completa de llamada al servicio.

Obtener un cliente

Esta operación es un poco distinta a las anteriores, ya que en este caso el resultado devuelto por el servicio será un objeto JSON y no un valor simple como en los casos anteriores. Al igual que en el caso de eliminación de clientes, la URL a utilizar será del tipo:

http://10.0.2.2:2731/Api/Clientes/Cliente/id_cliente

En este caso utilizaremos un tipo de petición http GET (objeto HttpGet) y la forma de realizar la llamada será análoga a las anteriores. Donde aparecerán las diferencias será a la hora de tratar el resultado devuelto por el servicio tras llamar al método getEntity(). Lo que haremos será crear un nuevo objeto JSONObject a partir del resultado textual de getEntity(). Hecho esto, podremos acceder a los atributos del objeto utilizando para ello los métodos get() correspondientes, según el tipo de cada atributo (getInt(), getString(), etc). Tras esto mostraremos los datos del cliente recuperado en la etiqueta de resultados de la interfaz (lblResultados).

HttpClient httpClient = new DefaultHttpClient();

String id = txtId.getText().toString();

HttpGet del =
	new HttpGet("http://10.0.2.2:2731/Api/Clientes/Cliente/" + id);

del.setHeader("content-type", "application/json");

try
{
       	HttpResponse resp = httpClient.execute(del);
       	String respStr = EntityUtils.toString(resp.getEntity());

       	JSONObject respJSON = new JSONObject(respStr);

       	int idCli = respJSON.getInt("Id");
       	String nombCli = respJSON.getString("Nombre");
       	int telefCli = respJSON.getInt("Telefono");

       	lblResultado.setText("" + idCli + "-" + nombCli + "-" + telefCli);
}
catch(Exception ex)
{
      	Log.e("ServicioRest","Error!", ex);
}

Una vez más como podéis comprobar el código es muy similar al ya visto para el resto de operaciones.

Obtener listado completo de clientes

Por último vamos a ver cómo podemos obtener el listado completo de clientes. El interés de esta operación está en que el resultado recuperado de la llamada al servicio será un array de objetos de tipo cliente, por supuesto en formato JSON. La acción http utilizada será una vez más la acción GET, y la URL para recuperar el listado de clientes será:

http://10.0.2.2:2731/Api/Clientes

De nuevo, la forma de llamar al servicio será análoga a las anteriores hasta la llamada a getEntity() para recuperar los resultados. En esta ocasión, dado que recibimos un array de elementos, convertiremos este resultado a un objeto JSONArray, y hecho esto podremos acceder a cada uno de los elementos del array mediante una llamada a getJSONObject(), al que iremos pasando el índice de cada elemento. Para saber cuántos elementos contiene el array podremos utilizar el método length() del objeto JSONArray. Por último, el acceso a los atributos de cada elemento del array lo realizamos exactamente igual como ya lo hicimos en la operación anterior de obtención de cliente por ID.

HttpClient httpClient = new DefaultHttpClient();

HttpGet del =
	new HttpGet("http://10.0.2.2:2731/Api/Clientes");

del.setHeader("content-type", "application/json");

try
{
       	HttpResponse resp = httpClient.execute(del);
       	String respStr = EntityUtils.toString(resp.getEntity());

       	JSONArray respJSON = new JSONArray(respStr);

       	String[] clientes = new String[respJSON.length()];

       	for(int i=0; i<respJSON.length(); i++)
       	{
       		JSONObject obj = respJSON.getJSONObject(i);

        	int idCli = obj.getInt("Id");
        	String nombCli = obj.getString("Nombre");
        	int telefCli = obj.getInt("Telefono");

       		clientes[i] = "" + idCli + "-" + nombCli + "-" + telefCli;
       	}

       	//Rellenamos la lista con los resultados
       	ArrayAdapter<String> adaptador =
       	       	new ArrayAdapter<String>(ServicioWebRest.this,
		        android.R.layout.simple_list_item_1, clientes);

	lstClientes.setAdapter(adaptador);
}
catch(Exception ex)
{
       	Log.e("ServicioRest","Error!", ex);
}

Tras obtener nuestro array de clientes, para mostrar los resultados hemos añadido a la interfas de nuestra aplicación de ejemplo un control tipo ListView (llamado lstClientes) que hemos rellenado a través de su adaptador con los datos de los clientes recuperados.

A modo de ejemplo, en la siguiente imagen puede verse el resultado de ejecutar la operación de listado completo de clientes:

Y con esto hemos terminado. Espero haber ilustrado con claridad en los dos últimos artículos la forma de construir servicios web tipo REST mediante ASP.NET y aplicaciones cliente Android capaces de acceder a dichos servicios.

Como siempre, podéis descargar el código fuente completo de este artículo mediante este enlace.

En este nuevo artículo vamos a crear un sistema similar, pero esta vez haciendo uso de la otra alternativa por excelencia a la hora de crear servicios web, y no es otra de utilizar servicios web tipo REST. Las famosas APIs que publican muchos de los sitios web actualmente no son más que servicios web de este tipo, aunque en la mayoría de los casos con medidas de seguridad adicionales tales como autenticación OAuth o similares.

REST también se asienta sobre el protocolo HTTP como mecanismo de transporte entre cliente y servidor, ya veremos después en qué medida. Y en cuanto al formato de los datos transmitidos, a diferencia de SOAP, no se impone ninguno en concreto, aunque lo más habitual actualmente es intercambiar la información en formato XML o JSON. Ya que en el caso de SOAP utilizamos XML, en este nuevo artículo utilizaremos JSON para construir nuestro ejemplo.

También vamos a utilizar un framework distinto para construir el servicio, aunque seguiremos haciéndolo en Visual Studio y en lenguaje C#. En este caso, en vez de utilizar ASP.NET a secas, vamos a utilizar el framework específico ASP.NET MVC 3, cuyo sistema de direccionamiento se ajusta mejor a los principios de REST, donde cada recurso [en nuestro caso cada cliente] debería ser accesible mediante su propia URL única. Podéis descargar MVC3 desde su página oficial de Microsoft.

En este primer artículo sobre servicios REST vamos a describir la construcción del servicio web en sí, y dedicaremos un segundo artículo a explicar cómo podemos acceder a este servicio desde una aplicación Android.

Empezamos. Lo primero que vamos a hacer será crear un nuevo proyecto en Visual Studio utilizando esta vez la plantilla llamada “ASP.NET MVC 3 Web Application“, lo llamaremos “ServicioWebRest“.

En la ventana de opciones del proyecto dejaremos todos los datos que aparecen por defecto y seleccionaremos como plantilla “Empty” para crear una aplicación vacía.

Esto debería crearnos el nuevo proyecto con la estructura de carpetas necesaria, que como veréis es bastante elaborada.  En nuestro caso vamos a crear el servicio web de forma aislada del resto de la aplicación web, y para ello lo primero que vamos a hacer es añadir una nueva Area al proyecto, a la que llamaremos por ejemplo “Api“, lo que nos creará una estructura de carpetas similar a la de la aplicación principal pero dentro de una carpeta independiente. Esto nos permite aislar todo el código y recursos de nuestro servicio web del resto de la aplicación web (que en nuestro caso no existirá porque no es el objetivo de este artículo, pero que podríamos crear sin problemas si lo necesitáramos).

Con esto, la estructura de nuestro proyecto será la siguiente:

Una vez que ya tenemos preparada toda la estructura de nuestro proyecto empecemos a añadir los elementos necesarios. Lo primero que vamos a crear será una nueva clase Cliente, igual que hicimos en el ejemplo anterior con SOAP. La colocaremos en la carpeta “Api/Models” y el código es el mismo que ya vimos:

namespace ServicioWebRest.Areas.Api.Models
{
    public class Cliente
    {
        public int Id { get; set; }
        public string Nombre { get; set; }
        public int Telefono { get; set; }
    }
}

El siguiente elemento a añadir será una nueva clase que contenga todas las operaciones que queramos realizar sobre nuestra base de datos de clientes. Llamaremos a la clase ClienteManager. En este caso sí vamos a añadir las cuatro operaciones básicas sobre clientes, y una adicional para obtener el listado completo, de forma que más tarde podamos mostrar la implementación en Android de todos los posibles tipos de llamada al servicio. Los métodos que añadiremos serán los siguientes:

• Cliente ObtenerCliente(int id)
• List<Clientes> ObtenerClientes()
• bool InsertarCliente(Cliente c)
• bool ActualizarCliente(Cliente c)
• bool EliminarCliente(int id)

Los dos primeros métodos nos servirán para recuperar clientes de la base de datos, tanto por su ID para obtener un cliente concreto, como el listado completo que devolverá una lista de clientes. Los otros tres métodos permitirán insertar, actualizar y eliminar clientes a partir de su ID y los datos de entrada (si aplica). El código de todos estos métodos es análogo a los ya implementados en el caso de SOAP, por lo que no nos vamos a parar en volverlos a comentar, tan sólo decir que utilizan la api clásica de ADO.NET para el acceso a SQL Server. En cualquier caso, al final del artículo tenéis como siempre el código fuente completo para poder consultar lo que necesitéis. A modo de ejemplo veamos la implementación de los métodos ObtenerClientes() e InsertarCliente().

public bool InsertarCliente(Cliente cli)
{
      SqlConnection con = new SqlConnection(cadenaConexion);

      con.Open();

      string sql = "INSERT INTO Clientes (Nombre, Telefono) VALUES (@nombre, @telefono)";

      SqlCommand cmd = new SqlCommand(sql,con);

      cmd.Parameters.Add("@nombre", System.Data.SqlDbType.NVarChar).Value = cli.Nombre;
      cmd.Parameters.Add("@telefono", System.Data.SqlDbType.Int).Value = cli.Telefono;

      int res = cmd.ExecuteNonQuery();

      con.Close();

      return (res == 1);
}

public List<Cliente> ObtenerClientes()
{
      List<Cliente> lista = new List<Cliente>();

      SqlConnection con = new SqlConnection(cadenaConexion);

      con.Open();

      string sql = "SELECT IdCliente, Nombre, Telefono FROM Clientes";

      SqlCommand cmd = new SqlCommand(sql,con);

      SqlDataReader reader =
            cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

      while (reader.Read())
      {
          Cliente cli = new Cliente();

          cli = new Cliente();
          cli.Id = reader.GetInt32(0);
          cli.Nombre = reader.GetString(1);
          cli.Telefono = reader.GetInt32(2);

          lista.Add(cli);
      }

      reader.Close();

      return lista;
}

Hasta ahora, todo el código que hemos escrito es bastante genérico y nada tiene que ver con que nuestro proyecto sea de tipo MVC. Sin embargo, los dos siguientes elementos sí que están directamente relacionados con el tipo de proyecto que tenemos entre manos.

Lo siguiente que vamos a añadir será un controlador a nuestro servicio web. Este controlador (clase ClientesController) será el encargado de contener las diferentes acciones que se podrán llamar según la URL y datos HTTP que recibamos como petición de entrada al servicio. Para nuestro ejemplo, añadiremos tan sólo dos acciones, una primera dirigida a gestionar todas las peticiones que afecten a un único cliente (insertar, actualizar, eliminar y obtener por ID), y otra que trate la petición del listado completo de clientes. Las llamaremos Clientes() y Cliente() respectivamente. Estas acciones harán uso de una instancia de la clase ClienteManager creada anteriormente para realizar las acciones necesarias contra la base de datos. Cada acción será también responsable de formatear sus resultados al formato de comunicación que hayamos elegido, en nuestro caso JSON.

La acción Clientes es muy sencilla, se limitará a llamar al método ObtenerClientes() y formatear los resultados como JSON. Para hacer esto último basta con crear directamente un objeto JsonResult llamado al método Json() pasándole como parámetro de entrada el objeto a formatear. Todo esto se reduce a una sola linea de código:

[HttpGet]
public JsonResult Clientes()
{
    return Json(this.clientesManager.ObtenerClientes(),
                JsonRequestBehavior.AllowGet);
}

Habréis notado también que hemos precedido el método con el atributo [HttpGet]. Para intentar explicar esto me hace falta seguir hablando de los principios de diseño de REST. Este tipo de servicios utiliza los propios tipos de petición definidos por el protocolo HTTP para diferenciar entre las operaciones a realizar por el servicio web. Así, el propio tipo de petición HTTP realizada (GET, POST, PUT o DELETE), junto con la dirección URL especificada en la llamada, nos determinará la operación a ejecutar por el servicio web. En el caso ya visto, el atributo [HttpGet] nos indica que dicho método se podrá ejecutar al recibirse una petición de tipo GET.

Entenderemos todo esto mejor ahora cuando veamos el código de la acción Cliente(). En esta acción, dependiente del tipo de petición HTTP recibida, tendremos que llamar a un método u otro del servicio web. Así, usaremos POST para las inserciones de clientes, PUT para las actualizaciones, GET para la consulta por ID y DELETE para las eliminaciones. En este caso no precedemos el método por ningún atributo, ya que la misma acción se encargará de tratar diferentes tipos de petición.

public JsonResult Cliente(int? id, Cliente item)
{
    switch (Request.HttpMethod)
    {
        case "POST":
            return Json(clientesManager.InsertarCliente(item));
        case "PUT":
            return Json(clientesManager.ActualizarCliente(item));
        case "GET":
            return Json(clientesManager.ObtenerCliente(id.GetValueOrDefault()),
                        JsonRequestBehavior.AllowGet);
        case "DELETE":
            return Json(clientesManager.EliminarCliente(id.GetValueOrDefault()));
    }

    return Json(new { Error = true, Message = "Operación HTTP desconocida" });
}

Algunos de vosotros seguro que os estáis preguntando cómo distinguirá el servicio cuándo llamar a la acción Clientes() para obtener el listado completo, o a la acción Cliente() para obtener un único cliente por su ID, ya que para ambas operaciones hemos indicado que se recibirá el tipo de petición http GET.

Pues bien, aquí es donde nos va a ayudar el último elemento a añadir al servicio web. Realmente no lo añadiremos, sino que lo modificaremos, ya que es un fichero que ya ha creado Visual Studio por nosotros. Se trata de la clase ApiAreaRegistration. La función de esta clase será la de dirigir las peticiones recibidas hacia una acción u otra del controlador según la URL utilizada al realizarse la llamada al servicio web.

En nuestro caso de ejemplo, vamos a reconocer dos tipos de URL. Una de ellas para acceder a la lista completa de cliente, y otra para realizar cualquier acción sobre un cliente en concreto:

• Lista de clientes: http://servidor/Api/Clientes
• Operación sobre cliente: http://servidor/Api/Clientes/Cliente/id_del_cliente

Cada uno de estos patrones tendremos que registrarlos mediante el método MapRoute() dentro del método RegisterArea() que ya tendremos creado dentro de la clase ApiAreaRegistration. Así, para registrar el primer tipo de URL haremos lo siguiente:

context.MapRoute(
    "AccesoClientes",
    "Api/Clientes",
    new
    {
        controller = "Clientes",
        action = "Clientes"
    }
);

Como primer parámetro de MapRoute() indicamos un nombre descriptivo para el patrón de URL. El segundo parámetro es el patrón en sí, que en este caso no tiene partes variables. Por último indicamos el controlador al que se dirigirán las peticiones que sigan este patrón eliminando el sufijo “Controller” (en nuestro caso será el controlador ClientesController) y la acción concreta a ejecutar dentro de dicho controlador (en nuestro caso la acción Clientes()).

Para el segundo tipo de URL será muy similar, con la única diferencia de que ahora habrá una parte final variable que se corresponderá con el ID del cliente y que asignaremos al parámetro “id” de la acción. En este caso además, dirigiremos la petición hacia la acción Cliente(), en vez de Clientes().

context.MapRoute(
    "AccesoCliente",
    "Api/Clientes/Cliente/{id}",
    new
    {
        controller = "Clientes",
        action = "Cliente",
        id = UrlParameter.Optional
    }
);

Como todo esto en cuenta, y por recapitular un poco, las posibles llamadas a nuestro servicio serán las siguientes:

GET  /Api/Clientes

Recuperará el listado completo de clientes y lo devolverá en formato JSON.

GET  /Api/Clientes/Cliente/3

Recuperará el cliente con el ID indicado en la URL y lo devolverá en formato JSON.

POST  /Api/Clientes/Cliente  { Nombre:”nombre”, Telefono:1234 }

Insertará un nuevo cliente con los datos aportados en la petición en formato JSON.

PUT  /Api/Clientes/Cliente/3  { Id:3, Nombre:”nombre”, Telefono:1234 }

Actualizará el cliente con el ID indicado en la URL con los datos aportados en la petición en formato JSON.

DELETE  /Api/Clientes/Cliente/3

Eliminará el cliente con el ID indicado en la URL.

Llegados aquí, tan sólo tenemos que ejecutar nuestro proyecto y esperar a que se abra el navegador web. En principio no se mostrará un error por no encontrar la página principal de la aplicación, ya que no hemos creado ninguna, pero nos asegurará que el servidor de prueba está funcionando, por lo que nuestro servicio debería responder a peticiones.

Así, si escribimos en la barra de direcciones por ejemplo la siguiente dirección (el puerto puede variar):

http://localhost:1234/Api/Clientes/Cliente/4

deberíamos recibir un fichero en formato JSON que contuviera los datos del cliente con ID = 4 de nuestra base de datos. Sería un fichero con contenido similar al siguiente:

{"Id":4,"Nombre":"cliente4","Telefono":4444}

En el siguiente artículo veremos cómo construir una aplicación Android capaz de acceder a este servicio y procesar los resultados recibidos. Podéis descargar el código fuente completo de este artículo desde este enlace.

En primer lugar hay que empezar diciendo que Android no incluye “de serie” ningún tipo de soporte para el acceso a servicios web de tipo SOAP. Es por esto por lo que vamos a utilizar una librería externa para hacernos más fácil esta tarea. Entre la oferta actual, la opción más popular y más utilizada es la librería ksoap2-android. Esta librería es un fork, especialmente adaptado para Android, de la antigua librería kSOAP2. Este framework nos permitirá de forma relativamente fácil y cómoda utilizar servicios web que utilicen el estándar SOAP. La última versión de esta librería en el momento de escribir este artículo es la 2.6.0, que puede descargarse desde este enlace.

Agregar esta librería a nuestro proyecto Android es muy sencillo. Una vez tenemos creado el proyecto en Android, accederemos al menú “Project / Properties” y en la ventana de propiedades accederemos a la sección “Java Build Path“. En esta sección accederemos a la solapa “Libraries” y pulsaremos el botón “Add External JARs…“. Aquí seleccionamos el fichero jar de la librería ksoap2-android (en este caso “ksoap2-android-assembly-2.6.0-jar-with-dependencies.jar”) y listo, ya tenemos nuestro proyecto preparado para hacer uso de la funcionalidad aportada por la librería.

Como aplicación de ejemplo, vamos a crear una aplicación sencilla que permita añadir un nuevo usuario a la base de datos. Para ello añadiremos a la vista principal dos cuadros de texto para introducir el nombre y teléfono del nuevo cliente (en mi caso se llamarán txtNombre y txtTelefono respectivamente) y un botón (en mi caso btnEnviar) que realice la llamada al método NuevoCliente del servicio web pasándole como parámetros los datos introducidos en los cuadros de texto anteriores.

No voy a mostrar todo el código necesario para crear esta vista y obtener las referencias a cada control porque no tiene ninguna particularidad sobre lo ya visto en multitud de ocasiones en artículos anteriores del curso (en cualquier caso al final del artículo podéis descargar todo el código fuente para su consulta). Lo que nos interesa en este caso es la implementación del evento onClick del botón btnEnviar, que será el encargado de comunicarse con el servicio web y procesar el resultado.

Lo primero que vamos a hacer en este evento es definir, por comodidad, cuatro constantes que nos servirán en varias ocasiones durante el código:

• NAMESPACE. Espacio de nombres utilizado en nuestro servicio web.
• URL. Dirección URL para realizar la conexión con el servicio web.
• METHOD_NAME. Nombre del método web concreto que vamos a ejecutar.
• SOAP_ACTION. Equivalente al anterior, pero en la notación definida por SOAP.

Aunque los valores se podrían más o menos intuir, para conocer exactamente los valores que debemos asignar a estas constantes vamos a ejecutar una vez más el proyecto de Visual Studio que construimos en el artículo anterior y vamos a acceder a la página de prueba del método NuevoCliente. Veremos algo parecido a lo siguiente:

En la imagen anterior se muestran resaltados en rojo los valores de las cuatro constantes a definir, que en nuestro caso concreto quedarían de la siguiente forma:

String NAMESPACE = "http://sgoliver.net/";
String URL="http://10.0.2.2:1473/ServicioClientes.asmx";
String METHOD_NAME = "NuevoClienteSimple";
String SOAP_ACTION = "http://sgoliver.net/NuevoClienteSimple";

Como podéis comprobar, y esto es algo importante, en la URL he sustituido el nombre de máquina localhost por su dirección IP equivalente, que en el caso de aplicaciones Android ejecutadas en el emulador se corresponde con la dirección 10.0.2.2, en vez de la clásica 127.0.0.1.

Los siguientes pasos del proceso serán crear la petición SOAP al servicio web, enviarla al servidor y recibir la respuesta. Aunque ya dijimos que todo este proceso sería casi transparente para el programador, por ser ésta la primera vez que hablamos del tema me voy a detener un poco más para intentar que entendamos lo que estamos haciendo y no solo nos limitemos a copiar/pegar trozos de código que no sabemos lo que hacen.

Volvamos a la página de prueba del método web NuevoCliente. Justo debajo de la sección donde se solicitan los parámetros a pasar al método se incluye también un XML de muestra de cómo tendría que ser nuestra petición al servidor si tuviéramos que construirla a mano. Echémosle un vistazo:

Una vez más he marcado varias zonas sobre la imagen, correspondientes a las tres partes principales de una petición de tipo SOAP. Empezando por la “parte interna” del XML, en primer lugar encontramos los datos de la petición en sí (Request) que contiene el nombre del método al que queremos llamar, y los nombres y valores de los parámetros en entrada. Rodeando a esta información se añaden otra serie de etiquetas y datos a modo de contenedor estándar que suele recibir el nombre de Envelope. La información indicada en este contenedor no es específica de nuestra llamada al servicio, pero sí contiene información sobre formatos y esquemas de validación del estándar SOAP. Por último, durante el envío de esta petición SOAP al servidor mediante el protocolo HTTP se añaden determinados encabezados como los que veis en la imagen. Todo esto junto hará que el servidor sea capaz de interpretar correctamente nuestra petición SOAP, se llame al método web correcto, y se devuelva el resultado en un formato similar al anterior que ya veremos más adelante. Aclarada un poco la estructura y funcionamiento general de una petición SOAP veamos lo sencillo que resulta realizarla desde nuestra aplicación Android.

En primer lugar crearemos la petición (request) a nuestro método NuevoCliente. Para ello crearemos un nuevo objeto SoapObject pasándole el namespace y el nombre del método web. A esta petición tendremos que asociar los parámetros de entrada mediante el método addProperty() al que pasaremos los nombres y valores de los parámetros (que en nuestro caso se obtendrán de los cuadros de texto de la vista principal).

SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);

request.addProperty("nombre", txtNombre.getText().toString());
request.addProperty("telefono", txtTelefono.getText().toString());

El segundo paso será crear el contenedor SOAP (envelope) y asociarle nuestra petición. Para ello crearemos un nuevo objeto SoapSerializationEnvelope indicando la versión de SOAP que vamos a usar (versión 1.1 en nuestro caso, como puede verse en la imagen anterior). Indicaremos además que se trata de un servicio web .NET activando su propiedad dotNet. Por último, asociaremos la petición antes creada a nuestro contenedor llamando al método setOutputSoapObject().

SoapSerializationEnvelope envelope =
	new SoapSerializationEnvelope(SoapEnvelope.VER11);

envelope.dotNet = true;

envelope.setOutputSoapObject(request);

Como tercer paso crearemos el objeto que se encargará de realizar la comunicación HTTP con el servidor, de tipo HttpTransportSE, al que pasaremos la URL de conexión a nuestro servicio web. Por último, completaremos el proceso realizando la llamada al servicio web mediante el método call().

HttpTransportSE transporte = new HttpTransportSE(URL);

try
{
	transporte.call(SOAP_ACTION, envelope);

	//Se procesa el resultado devuelto
	//...
}
catch (Exception e)
{
	txtResultado.setText("Error!");
}

Tras la llamada al servicio ya estamos en disposición de obtener el resultado devuelto por el método web llamado. Esto lo conseguimos mediante el método getResponse(). Dependiendo del tipo de resultado que esperemos recibir deberemos convertir esta respuesta a un tipo u otro. En este caso, como el resultado que esperamos es un valor simple (un número entero) convertiremos la respuesta a un objeto SoapPrimitive, que directamente podremos convertir a una cadena de caracteres llamado a toString(). Más adelante veremos cómo tratar valores de retorno más complejos.

SoapPrimitive resultado_xml =(SoapPrimitive)envelope.getResponse();
String res = resultado_xml.toString();

if(res.equals("1"))
	txtResultado.setText("Insertado OK");

Y listo, con esto ya tenemos preparada la llamada a nuestro servicio web y el tratamiento de la respuesta recibida.

Un detalle más antes de poder probar todo el sistema. Debemos acordarnos de conceder permiso de acceso a internet a nuestra aplicación, añadiendo la linea correspondiente al Android Manifest:

<uses-permission android:name="android.permission.INTERNET"/>

Pues bien, para probar lo que llevamos hasta ahora podemos ejecutar ambos proyectos simultáneamente, en primer lugar el de Visual Studio para iniciar la ejecución del servidor local que alberga nuestro servicio web (hay que dejar abierto el explorador una vez que se abra), y posteriormente el de Eclipse para iniciar nuestra aplicación Android en el Emulador. Una vez están los dos proyectos en ejecución, podemos rellenar los datos de nuestro cliente en la aplicación Android y pulsar el botón “Enviar” para realizar la llamada al servicio web e insertar el cliente en la base de datos (que por supuesto también deberá estar iniciada). Si todo va bien y no se produce ningún error, deberíamos poder consultar la tabla de Clientes a través del SQL Server Management Studio para verificar que el cliente se ha insertado correctamente.

En la imagen vemos cómo hemos insertado un nuevo cliente llamada ‘cliente7′ con número de teléfono ’7777′. Si consultamos ahora nuestra base de datos Sql Server podremos comprobar si el registro efectivamente se ha insertado correctamente.

Con esto, ya sabemos realizar una llamada a un servicio web SOAP que devuelve un valor de retorno sencillo, en este caso un simple número entero. Lo siguiente que vamos a ver será como implementar la llamada a un método del servicio web que nos devuelva un valor algo más complejo. Y esto lo vamos a ver con la llamada al método web ListadoClientes() que recordemos devolvía un array de objetos de tipo Cliente.

En este caso, la llamada al método web se realizará de forma totalmente análoga a la ya comentada. Donde llegarán las diferencias será a la hora de tratar el resultado devuelto por el servicio, comenzando por el resultado del método getResponse() de ksoap. En esta ocasión, dado que el resultado esperado no es ya un valor simple sino un objeto más complejo, convertiremos el resultado de getResponse() al tipo SoapObject, en vez de SoapPrimitive como hicimos anteriormente. Nuestro objetivo será generar un array de objetos Cliente (lo llamaremos listaClientes) a partir del resultado devuelto por la llamada al servicio.

Como sabemos que el resultado devuelto por el servicio es también un array, lo primero que haremos será crear un array local con la misma longitud que el devuelto, lo que conseguiremos mediante el método getPropertyCount(). Tras esto, iteraremos por los distintos elementos del array devuelto mediante el método getProperty(ind), donde ind será el índice de cada ocurrencia. Cada uno de estos elementos será a su vez otro objeto de tipo SoapObject, que representará a un Cliente. Adicionalmente, para cada elemento accederemos a sus propiedades (Id, Nombre, y Telefono) una vez más mediante llamadas a getProperty(), con el índice de cada atributo, que seguirá el mismo orden en que se definieron. Así, getProperty(0) recuperará el Id del cliente, getProperty(1) el nombre, y getProperty(2) el teléfono. De esta forma podremos crear nuestros objetos Cliente locales a partir de estos datos. Al final de cada iteración añadimos el nuevo cliente recuperado a nuestro array. Veamos como quedaría todo esto en el código, donde seguro que se entiende mejor:

SoapObject resSoap =(SoapObject)envelope.getResponse();

Cliente[] listaClientes = new Cliente[resSoap.getPropertyCount()];

for (int i = 0; i < listaClientes.length; i++)
{
       SoapObject ic = (SoapObject)resSoap.getProperty(i);

       Cliente cli = new Cliente();
       cli.id = Integer.parseInt(ic.getProperty(0).toString());
       cli.nombre = ic.getProperty(1).toString();
       cli.telefono = Integer.parseInt(ic.getProperty(2).toString());

       listaClientes[i] = cli;
}

En nuestra aplicación de ejemplo añadimos un nuevo botón y un control tipo lista (lo llamo lstClientes), de forma que al pulsar dicho botón rellenemos la lista con los nombres de todos los clientes recuperados. La forma de rellenar una lista con un array de elementos ya la vimos en los artículos dedicados a los controles de selección, por lo que no nos pararemos a comentarlo. El código sería el siguiente (Nota: sé que todo esto se podría realizar de forma más eficiente sin necesidad de crear distintos arrays para los clientes y para el adaptador de la lista, pero lo dejo así para no complicar el tutorial con temas ya discutidos en otros artículos):

//Rellenamos la lista con los nombres de los clientes
final String[] datos = new String[listaClientes.length];

for(int i=0; i<listaClientes.length; i++)
    datos[i] = listaClientes[i].nombre;

ArrayAdapter<String> adaptador =
    new ArrayAdapter<String>(ServicioWebSoap.this,
        android.R.layout.simple_list_item_1, datos);

lstClientes.setAdapter(adaptador);

Por último, vamos a ver cómo llamar a un método web que recibe como parámetro algún objeto complejo. Para ilustrarlo haremos una llamada al segundo método de inserción de clientes que implementamos en el servicio, NuevoClienteObjeto(). Recordemos que este método recibía como parámetro de entrada un objeto de tipo Cliente.

Para poder hacer esto, lo primero que tendremos que hacer será modificar un poco nuestra clase Cliente, de forma que ksoap sepa cómo serializar nuestros objetos Cliente a la hora de generar las peticiones SOAP correspondientes. Y para esto, lo que haremos será implementar la interfaz KvmSerializable en nuestra clase Cliente. Para ello, además de añadir la cláusula implements correspondiente tendremos que implementar los siguientes métodos:

• getProperty(int indice)
• getPropertyCount()
• getPropertyInfo(int indice, HashTable ht, PropertyInfo info)
• setProperty(int indice, Object valor)

El primero de ellos deberá devolver el valor de cada atributo de la clase a partir de su índice de orden. Así, para el índice 0 se devolverá el valor del atributo Id, para el índice 1 el del atributo Nombre, y para el 2 el atributo Teléfono.

@Override
public Object getProperty(int arg0) {

	switch(arg0)
        {
        case 0:
            return id;
        case 1:
            return nombre;
        case 2:
            return telefono;
        }

	return null;
}

El segundo de los métodos, deberá devolver simplemente el número de atributos de nuestra clase, que en nuestro caso será 3 (Id, Nombre y Telefono):

@Override
public int getPropertyCount() {
	return 3;
}

El objetivo del tercero será informar, según el índice recibido como parámetro, el tipo y nombre del atributo correspondiente. El tipo de cada atributo se devolverá como un valor de la clase PropertyInfo.

@Override
public void getPropertyInfo(int ind, Hashtable ht, PropertyInfo info) {
	switch(ind)
        {
        case 0:
            info.type = PropertyInfo.INTEGER_CLASS;
            info.name = "Id";
            break;
        case 1:
            info.type = PropertyInfo.STRING_CLASS;
            info.name = "Nombre";
            break;
        case 2:
            info.type = PropertyInfo.INTEGER_CLASS;
            info.name = "Telefono";
            break;
        default:break;
        }
}

Por último, el método setProperty() será el encargado de asignar el valor de cada atributo según su índice y el valor recibido como parámetro.

@Override
public void setProperty(int ind, Object val) {
	switch(ind)
        {
        case 0:
            id = Integer.parseInt(val.toString());
            break;
        case 1:
            nombre = val.toString();
            break;
        case 2:
            telefono = Integer.parseInt(val.toString());
            break;
        default:
            break;
        }
}

Mediante estos métodos, aunque de forma transparente para el programados, ksoap será capaz de transformar nuestros objetos Cliente al formato XML correcto de forma que pueda pasarlos como parámetro en las peticiones SOAP a nuestro servicio.

Por su parte, la llamada al servicio también difiere un poco de lo ya comentado a la hora de asociar los parámetros de entrada del método web. En este caso, construiremos en primer lugar el objeto Cliente que queremos insertar en la base de datos a partir de los datos introducidos en la pantalla de nuestra aplicación de ejemplo. Tras esto crearemos un nuevo objeto PropertyInfo, al que asociaremos el nombre, valor y tipo de nuestro cliente mediante sus métodos setName(), setValue() y setClass() respectivamente. Por último, asociaremos este cliente como parámetro de entrada al servicio llamando al metodo addProperty() igual que hemos hecho en las anteriores ocasiones, con la diferencia de que esta vez lo llamaremos pasándole el objeto PropertyInfo que acabamos de crear. Además de esto, tendremos también que llamar finalmente al método addMapping() para asociar de alguna forma nuestro espacio de nombres y nombre de clase “Cliente” con la clase real java. Veamos el código para entenderlo mejor:

Cliente cli = new Cliente();
cli.nombre = txtNombre.getText().toString();
cli.telefono = Integer.parseInt(txtTelefono.getText().toString());

PropertyInfo pi = new PropertyInfo();
pi.setName("cliente");
pi.setValue(cli);
pi.setType(cli.getClass());

request.addProperty(pi);

SoapSerializationEnvelope envelope =
    new SoapSerializationEnvelope(SoapEnvelope.VER11);
envelope.dotNet = true;

envelope.setOutputSoapObject(request);

envelope.addMapping(NAMESPACE, "Cliente", cli.getClass());

Todo esto lo haremos en un nuevo botón añadido a la aplicación de ejemplo (Enviar2), cuyo efecto tendrá que ser idéntico al que ya creamos para la llamada al método web NuevoClienteSimple(), aunque como acabamos de ver su implementación es algo diferente debido a los distintos parámetros de entrada utilizados.

Como imagen final veamos una captura de la pantalla final de nuestra aplicación de ejemplo, donde vemos los tres botones implementados, junto al resultado de la ejecución de cada uno, el mensaje “Insertado OK” de los métodos de inserción, y la lista de clientes recuperada por el método de consulta.

Espero que estos dos últimos artículos sobre servicios web SOAP y Android os sirvan para tener un ejemplo completo, tanto de la parte servidor como de la parte cliente, que os sirva de base para crear nuevos sistemas adaptados a vuestras necesidades. Como siempre, podéis descargar el código fuente completo de este artículo a través de este enlace.

A diferencia de otros tutoriales, no sólo vamos describir cómo acceder a este tipo de servicios desde una aplicación Android, sino que también veremos como crear un servicio web SOAP mediante ASP.NET para acceder a una base de datos SQL Server. De esta forma pretendo ilustrar la “arquitectura” completa de una aplicación Android que acceda a datos almacenados en un servidor de base de datos externo. Nota: Aunque intentaré aportar el máximo número de detalles, es imposible abarcarlo todo en un solo artículo, por lo que el texto supondrá unos conocimientos mínimos de Visual Studio y del lenguaje C#.

Como caso de ejemplo, vamos a crear una aplicación sencilla capaz de gestionar un listado de “clientes” que contendrá el nombre y teléfono de cada uno de ellos. Nuestra aplicación será capaz de consultar el listado actual de clientes almacenados en el servidor externo y de insertar nuevos clientes en la base de datos. Como siempre, se trata de un ejemplo muy sencillo pero creo que lo suficientemente completo como para que sirva de base para crear otras aplicaciones más complejas.

Como software necesario, en este caso utilizaré Visual Studio 2010 y SQL Server 2008 R2 para crear el servicio web y la base de datos respectivamente.  Podéis descargar de forma gratuita las versiones Express de ambos productos (más que suficientes para crear una aplicación como la que describiremos en este artículo) desde la web oficial de Microsoft. También es recomendable instalar SQL Server 2008 Management Studio Express, descargable también de forma gratuita desde esta web. Esta aplicación no es más que un gestor gráfico para acceder y manipular nuestras bases de datos  SQL Server con total comodidad.

Vamos comenzar por la base de todo el sistema, y esto es la base de datos a la que accederá el servicio web y, a través de éste, también la aplicación Android que crearemos más adelante. Para ello abrimos SQL Server Management Studio, nos conectamos a nuestro servidor SQL Server local, y pulsamos sobre la sección “Databases” del árbol de objetos que aparece a la izquierda. Sobre esta carpeta podemos acceder a la opción “New Database…” del menú contextual para crear una nueva base de datos.

En el cuadro de diálogo que aparece tan sólo indicaremos el nombre de la nueva base de datos, en mi caso la llamaré DBCLIENTES, y dejaremos el resto de opciones con sus valores por defecto.

Desplegamos el árbol de carpetas de nuestra recién creada base de datos DBCLIENTES y sobre la carpeta “Tables” ejecutamos la opción “New table…” para crear una nueva tabla.

Vamos a añadir sólo 3 campos a la tabla:

• IdCliente, de tipo int, que será un código único identificativo del cliente.
• Nombre, de tipo nvarchar(50), que contendrá el nombre del cliente.
• Telefono, de tipo int, que contendrá el teléfono del cliente.

Marcaremos además el campo IdCliente como clave principal de la tabla, y también como campo de identidad autoincremental, de modo que se calcule automáticamente cada vez que insertemos un nuevo cliente.

Con esto ya tenemos nuestra tabla finalizada, por lo que sólo nos queda guardarla con el nombre que deseemos, que para este ejemplo será “Clientes“.

Hecho, ya tenemos nuestra base de datos SQL Server creada y una tabla preparada para almacenar los datos asociados a nuestros clientes. El siguiente paso será crear el servicio web que manipulará los datos de esta tabla.

Para crear el servicio abriremos Visual Studio 2010 y crearemos un nuevo proyecto web en C# utilizando la plantilla “ASP.NET Empty Web Application“. En un alarde de originalidad lo llamaremos “ServicioWebSoap“.

Una vez creado el proyecto, añadiremos a éste un nuevo servicio web mediante el menú “Project / Add new item…“. Lo llamaremos “ServicioClientes.asmx“.

Una vez añadido aparecerá en pantalla el código fuente por defecto del nuevo servicio web, que contiene un único método de ejemplo llamado HelloWorld(). Este método podemos eliminarlo ya que no nos servirá de nada, y además modificaremos el atributo WebService de la clase para indicar que el namespace será “http://sgoliver.net/” (en vuestro caso podéis indicar otro valor). Con esto, nos quedaría un código base como éste:

namespace ServicioWebSoap
{
    /// <summary>
    /// Summary description for ServicioClientes
    /// </summary>
    [WebService(Namespace = "http://sgoliver.net/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]

    public class ServicioClientes : System.Web.Services.WebService
    {
        //Métodos del servicio web
        //...
    }
}

Pues bien, dentro de esta clase ServicioClientes es donde añadiremos todos los métodos públicos que queramos tener accesibles a través de nuestro servicio web, siempre precedidos por el atributo [WebMethod] como veremos en breve. Para nuestro ejemplo vamos a crear tres métodos, el primero para obtener el listado completo de clientes almacenados en la base de datos, y los otros dos para insertar nuevos clientes (más adelante explicaré por qué dos, aunque adelanto que es tan sólo por motivos didácticos).

Antes de crear estos métodos, vamos a crear una nueva clase sencilla que nos sirva para encapsular los datos de un cliente. La añadiremos mediante la opción “Project / Add class…” de Visual Studio y la llamaremos “Cliente.cs“. Esta clase contendrá únicamente los 3 campos que ya comentamos al crear la base de datos y dos constructores, uno de ellos por defecto que tan solo inicializará los campos y otro con parámetros para crear clientes a partir de sus datos identificativos. El código de la clase es muy sencillo, y tan solo cabe mencionar que definiremos sus tres atributos como propiedades automáticas de C# utilizando para ello la notación abreviada {get; set;}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace ServicioWebSoap
{
    public class Cliente
    {
        public int Id {get; set;}
        public string Nombre {get; set;}
        public int Telefono {get; set;}

        public Cliente()
        {
            this.Id = 0;
            this.Nombre = "";
            this.Telefono = 0;
        }

        public Cliente(int id, string nombre, int telefono)
        {
            this.Id = id;
            this.Nombre = nombre;
            this.Telefono = telefono;
        }
    }
}

Vamos ahora a escribir el primero de los métodos que haremos accesible a través de nuestro servicio web. Lo llamaremos NuevoCliente(), recibirá como parámetros de entrada un nombre y un teléfono, y se encargará de insertar un nuevo registro en nuestra tabla de clientes con dichos datos. Recordemos que el ID del cliente no será necesario insertarlo de forma explícita ya que lo hemos definido en la base de datos como campo autoincremental. Para el trabajo con la base de datos vamos a utilizar la API clásica de ADO.NET, aunque podríamos utilizar cualquier otro mécanismo de acceso a datos, como por ejemplo Entity Framework, NHibernate, etc.

De esta forma, el primer paso será crear una conexión a SQL Server mediante la clase SQLConnection, pasando como parámetro la cadena de conexión correspondiente (en vuestro caso tendréis que modificarla para adaptarla a vuestro entorno). Tras esto abriremos la conexión mediante una llamada al método Open(), definiremos el comando SQL que queremos ejecutar creando un objeto SQLCommand. Ejecutaremos el comando llamando al método ExecuteNonQuery() recogiendo el resultado en una variable, y finalmente cerraremos la conexión llamando a Close(). Por último devolveremos el resultado del comando SQL como valor de retorno del método web.

Como podéis ver en el código siguiente, los valores a insertar en la base de datos los hemos especificado en la consulta SQL como parámetros variable (precedidos por el carácter ‘@’). Los valores de estos parámetros los definimos y añadimos al comando SQL mediante el método Add() de su propiedad Parameters. Esta opción es más recomendable que la opción clásica de concatenar directamente la cadena de texto de la sentencia SQL con los parámetros variables, ya que entre otras cosas servirá para evitar [en gran medida] posibles ataques de inyección SQL. El resultado devuelto por este método será el número de registros afectados por la sentencia SQL ejecutada, por lo que para verificar si se ha ejecutado correctamente bastará con comprobar que el resultado es igual a 1.

[WebMethod]
public int NuevoClienteSimple(string nombre, int telefono)
{
    SqlConnection con =
        new SqlConnection(
            @"Data Source=SGOLIVERPC\SQLEXPRESS;Initial Catalog=DBCLIENTES;Integrated Security=True");

    con.Open();

    string sql = "INSERT INTO Clientes (Nombre, Telefono) VALUES (@nombre, @telefono)";

    SqlCommand cmd = new SqlCommand(sql, con);

    cmd.Parameters.Add("@nombre", System.Data.SqlDbType.NVarChar).Value = nombre;
    cmd.Parameters.Add("@telefono", System.Data.SqlDbType.Int).Value = telefono;

    int res = cmd.ExecuteNonQuery();

    con.Close();

    return res;
}

En el código anterior, podéis ver que hemos precedido el método con el atributo [WebMethod]. Con este atributo estamos indicando que el método será accesible a través de nuestro servicio web y podrá ser llamado desde cualquier aplicación que se conecte con éste.

La siguiente operación que vamos a añadir a nuestro servicio web será la que nos permita obtener el listado completo de clientes registrados en la base de datos. Llamaremos al método ListadoClientes() y devolverá un array de objetos de tipo Cliente. El código del método será muy similar al ya comentado para la operación de inserción, con la única diferencia de que en esta ocasión la sentencia SQL será obviamente un SELECT y que utilizaremos un objeto SqlDataReader para leer los resultados devueltos por la consulta. Los registros leídos los iremos añadiendo a una lista de tipo List<Clientes> y una vez completada la lectura convertiremos esta lista en un array de clientes llamando al método ToArray(). Este último array será el que devolveremos como resultado del método. Veamos el código completo del método:

[WebMethod]
public Cliente[] ListadoClientes()
{
    SqlConnection con =
        new SqlConnection(
            @"Data Source=SGOLIVERPC\SQLEXPRESS;Initial Catalog=DBCLIENTES;Integrated Security=True");

    con.Open();

    string sql = "SELECT IdCliente, Nombre, Telefono FROM Clientes";

    SqlCommand cmd = new SqlCommand(sql, con);

    SqlDataReader reader = cmd.ExecuteReader();

    List<Cliente> lista = new List<Cliente>();

    while (reader.Read())
    {
        lista.Add(
            new Cliente(reader.GetInt32(0),
                        reader.GetString(1),
                        reader.GetInt32(2)));
    }

    con.Close();

    return lista.ToArray();
}

Por último, como dijimos al principio, vamos a añadir un tercer método web con fines puramente didácticos. Si os fijáis en los dos métodos anteriores, veréis que en uno de los casos devolvemos como resultado un valor simple, un número entero, y en el otro caso un objeto complejo, en concreto un array de objetos de tipo Cliente. Sin embargo, ninguno de ellos recibe como parámetro un tipo complejo, tan sólo valores simples (enteros y strings). Esto no tiene mucha relevancia en el código de nuestro servicio web, pero sí tiene ciertas peculiaridades a la hora de realizar la llamada al servicio desde la aplicación Android. Por lo que para poder explicar esto más adelante añadiremos un nuevo método de inserción de clientes que, en vez de recibir los parámetros de nombre y teléfono por separado, recibirá como dato de entrada un objeto Cliente.

El código de este método, que llamaremos NuevoClienteObjeto(), será exactamente igual al anterior método de inserción, con la única diferencia de los parámetros de entrada, por lo que no nos detendremos en comentar nada más.

[WebMethod]
public int NuevoClienteObjeto(Cliente cliente)
{
    SqlConnection con = new SqlConnection(@"Data Source=SGOLIVERPC\SQLEXPRESS;Initial Catalog=DBCLIENTES;Integrated Security=True");

    con.Open();

    string sql = "INSERT INTO Clientes (Nombre, Telefono) VALUES (@nombre, @telefono)";

    SqlCommand cmd = new SqlCommand(sql, con);

    cmd.Parameters.Add("@nombre", System.Data.SqlDbType.NVarChar).Value = cliente.Nombre;
    cmd.Parameters.Add("@telefono", System.Data.SqlDbType.Int).Value = cliente.Telefono;

    int res = cmd.ExecuteNonQuery();

    con.Close();

    return res;
}

Y con esto hemos finalizado nuestro servicio web. Podemos probar su funcionamiento con la página de prueba que proporciona ASP.NET al ejecutar el proyecto en Visual Studio. Si ejecutamos el proyecto se abrirá automáticamente un explorador web que mostrará una página con todas las operaciones que hemos definido en el servicio web.

Si pulsamos sobre cualquiera de ellas pasaremos a una nueva página que nos permitirá dar valores a sus parámetros y ejecutar el método correspondiente para visualizar sus resultados. Si pulsamos por ejemplo en la operación NuevoCliente(string, int) llegaremos a esta página:

Aquí podemos dar valores a los dos parámetros y ejecutar el método (botón “Invoke“), lo que nos devolverá la respuesta codificada en un XML según el estandar SOAP.

Como podéis comprobar, en principio el XML devuelto no es fácil de interpretar, pero esto es algo que no debe preocuparnos demasiado ya que en principio será transparente para nosotros, las librerías que utilizaremos más adelante en Android para la llamada a servicios SOAP se encargarán de parsear convenientemente estas respuestas y de darnos tan sólo aquella parte que necesitamos.

En el siguiente artículo nos ocuparemos de la construcción de una aplicación Android que sea capaz de conectarse a este servicio web y de llamar a los métodos que hemos definido para insertar y recuperar clientes de nuestra base de datos. Veremos además cómo podemos ejecutar y probar en local todo el sistema de forma que podamos comprobar que todo funciona como esperamos.

Podéis descargar el código fuente completo del servicio web desde este enlace.

Hace ya algún tiempo dedicamos varios artículos (I, II, III, IV) al tratamiento de ficheros XML en Android y vimos varias alternativas a la hora de leer (parsear) ficheros de este tipo. En todos los ejemplos decidí utilizar como entrada un fichero online, que obteníamos desde una determinada URL, porque pensé que sería el caso más típico que íbamos a necesitar en la mayoría de aplicaciones. Sin embargo, desde entonces han sido muchas las consultas que me han llegado relativas a cómo utilizar estos métodos para leer un fichero XML que se encuentre en un recurso local. Adicionalmente también he recibido muchos comentarios consultando las alternativas existentes para escribir ficheros XML. Pues bien, aunque las alternativas son muchas, voy a dedicar este pequeño artículo a intentar resolver ambas dudas.

Escribir ficheros XML en Android

Para escribir ficheros XML sin meternos en muchas complicaciones innecesarias se me ocurren básicamente dos formas. La primera de ellas, y la más sencilla y directa, es construir manualmente el XML utilizando por ejemplo un objeto StringBuilder y tras esto escribir el resultado a un fichero en memoria interna o externa tal como ya vimos en los artículos dedicados a tratamiento de ficheros (I y II). Esto quedaría de una forma similar a la siguiente:

//Creamos un fichero en la memoria interna
OutputStreamWriter fout =
	new OutputStreamWriter(
		openFileOutput("prueba.xml",
			Context.MODE_PRIVATE));

StringBuilder sb = new StringBuilder();

//Construimos el XML
sb.append("");
sb.append("" + "Usuario1" + "");
sb.append("" + "ApellidosUsuario1" + "");
sb.append("");

//Escribimos el resultado a un fichero
fout.write(sb.toString());
fout.close();

Como método alternativo también podemos utilizar el serializador XML incluido con la API XmlPull. Aunque no es un método tan directo como el anterior no deja de ser bastante intuitivo. Los pasos para conseguir esto serán crear el objeto XmlSerializer, crear el fichero de salida, asignar el fichero como salida del serializador y construir el XML mediante los métodos startTag(), text() y endTag() pasándoles los nombres de etiqueta y contenidos de texto correspondientes (aunque existen más métodos, por ejemplo para escribir atributos de una etiqueta, éstos tres son los principales). Finalmente deberemos llamar a endDocument() para finalizar y cerrar nuestro documento XML. Un ejemplo equivalente al anterior utilizando este método sería el siguiente:

//Creamos el serializer
XmlSerializer ser = Xml.newSerializer();

//Creamos un fichero en memoria interna
OutputStreamWriter fout =
	new OutputStreamWriter(
		openFileOutput("prueba_pull.xml",
			Context.MODE_PRIVATE));

//Asignamos el resultado del serializer al fichero
ser.setOutput(fout);

//Construimos el XML
ser.startTag("", "usuario");

ser.startTag("", "nombre");
ser.text("Usuario1");
ser.endTag("", "nombre");

ser.startTag("", "apellidos");
ser.text("ApellidosUsuario1");
ser.endTag("", "apellidos");

ser.endTag("", "usuario");

ser.endDocument();

fout.close();

Así de sencillo, no merece la pena complicarse la vida con otros métodos más complicados.

Leer ficheros XML en Android desde recursos locales

Para leer ficheros XML desde un recurso local se me ocurren varias posibilidades, por ejemplo leerlo desde la memoria interna/externa del dispositivo, leer un XML desde un recurso XML (carpeta /res/xml), desde un recurso Raw (carpeta /res/raw), o directamente desde la carpeta /assets de nuestro proyecto. Salvo en el segundo caso (recurso XML), en todos los demás la solución va a pasar por conseguir una referencia de tipo InputStream (os recuerdo que cualquiera de los métodos que vimos para leer un XML partían de una referencia de este tipo) a partir de nuestro fichero o recurso XML, sea cual sea su localización.

Así, por ejemplo, si el fichero XML está almacenado en la memoria interna de nuestro dispositivo, podríamos acceder a él mediante el método openFileInput() tal como vimos en los artículos dedicados a tratamiento de ficheros. Este método devuelve un objeto de tipo FileInputStream, que al derivar de InputStream podemos utilizarlo como entrada a cualquiera de los mecanismos de lectura de XML (SAX, DOM, XmlPull).

//Obtenemos la referencia al fichero XML de entrada
FileInputStream fil = openFileInput("prueba.xml");

//DOM (Por ejemplo)
DocumentBuilderFactory factory =
    DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(fil);

//A partir de aquí se trataría el árbol DOM como siempre.
//Por ejemplo:
Element root = dom.getDocumentElement();

//...

En el caso de encontrarse el fichero como recurso Raw, es decir, en la carpeta /res/raw, tendríamos que obtener la referencia al fichero mediante el método getRawResource() pasándole como parámetro el ID de recurso del fichero. Esto nos devuelve directamente el stream de entrada en forma de InputStream.

//Obtenemos la referencia al fichero XML de entrada
InputStream is = getResources().openRawResource(R.raw.prueba);

//DOM (Por ejemplo)
DocumentBuilderFactory factory =
    DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(is);

//A partir de aquí se trataría el árbol DOM como siempre.
//Por ejemplo:
Element root = dom.getDocumentElement();

//...

Por último, si el XML se encontrara en la carpeta /assets de nuestra aplicación, accederíamos a él a través del AssetManager, el cual podemos obtenerlo con el método getAssets() de nuestra actividad. Sobre este AssetManager tan sólo tendremos que llamar al método open() con el nombre del fichero para obtener una referencia de tipo InputStream a nuestro XML.

//Obtenemos la referencia al fichero XML de entrada
AssetManager assetMan = getAssets();
InputStream is = assetMan.open("prueba_asset.xml");

//DOM (Por ejemplo)
DocumentBuilderFactory factory =
    DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(is);

//A partir de aquí se trataría el árbol DOM como siempre.
//Por ejemplo:
Element root = dom.getDocumentElement();

//...

El último caso, algo distinto a los anteriores, pasaría por leer el XML desde un recurso XML localizado en la carpeta /res/xml de nuestro proyecto. Para acceder a un recurso de este tipo debemos utilizar el método getXml() al cual debemos pasarle como parámetro el ID de recurso del fichero XML. Esto nos devolverá un objeto XmlResourceParser, que no es más que un parser de tipo XmlPull como el que ya comentamos en su momento. Por tanto, la forma de trabajar con este parser será idéntica a la que ya conocemos, por ejemplo:

//Obtenemos un parser XmlPull asociado a nuestro XML
XmlResourceParser xrp = getResources().getXml(R.xml.prueba);

//A partir de aquí utilizamos la variable 'xrp' como
//cualquier otro parser de tipo XmlPullParser. Por ejemplo:

int evento = xrp.getEventType();

if(evento == XmlPullParser.START_DOCUMENT)
	Log.i("XmlTips", "Inicio del documento");

//...

Por último, indicar que todas estas formas de acceder a un fichero en Android no se limitan únicamente a los de tipo XML, sino que pueden utilizarse para leer cualquier otro tipo de ficheros.

Como siempre, podéis descargar el código fuente completo de un sencillo programa de ejemplo que utiliza cada una de las alternativas comentadas.

Creo que las respuestas a ambas preguntas están claras, pero si tenéis cualquier problema con el registro no tenéis más que poneros en contacto conmigo vía email.

Adicionalmente, he eliminado algunos de los últimos usuarios registrados, bajo la sospecha de que pueda tratarse de bots de spam. Pido disculpas si alguna de las cuentas eliminadas pertenecía a algún usuario real del foro. Si es así tan sólo tenéis que volver a realizar el registro con el mismo nombre de usuario.

Siento las molestias.

A nivel general, las estadísticas más importantes se muestran en la siguiente imagen:

Estadísiticas Generales 2011

Comparando los datos con los del año pasado el porcentaje de mejora es realmente grande. El número de visitas se ha multiplicado por 9, el promedio de páginas vistas ha crecido algo más de 1.1 páginas, el promedio de tiempo en el sitio ha aumentado en más de 2 minutos,  y el porcentaje de rebote ha disminuido más de 12 puntos. Con todo esto, acabamos el año con una media de unas 1100 visitas diarias, aunque la media en los últimos meses es muy superior.

En cuanto al número de visitas por país, España es naturalmente el origen mayoritario de las visitas, con más de un 55% del total, pero también ha crecido mucho el porcentaje de visitas desde paises sudamericanos. Muchas gracias a todos los que seguís el blog desde el otro lado del charco.

Visitas por Pais

Las páginas más visitadas en este último año han sido sin lugar a dudas las dedicadas al Curso de Programación en Android. Por supuesto el índice del curso se lleva el mayor porcentaje (27.70% de las páginas vistas), y como mayoría dentro del TOP 10, los artículos de iniciación del curso (entorno de desarrollo, componentes de una aplicación, estructura de un proyecto, y desarrollo de la primera aplicación).

Páginas más visitadas

Por último, si miramos las fuentes del tráfico que llega a la web vemos el siguiente desglose.

Fuentes del tráfico

Más de la mitad de las visitas han llegado desde alguna búsqueda en un buscador de internet (Google en un 98%) lo que hace pensar que el posicionamiento del blog no funciona del todo mal. Además, ha crecido en gran medida el tráfico de referencia lo que también es una buena noticia, que te enlacen desde otras webs siempre es del agrado de todos y por supuesto beneficioso para los usuarios.

En fin, que a pesar de tratarse de números modestos, parece que poco a poco seguimos mejorando. Esperemos que el año próximo podamos decir lo mismo. Felices fiestas, y buen comienzo de año a todos.

De forma paralela estoy actualizando algunos contenidos para que se adapten todo lo posible al nuevo diseño, tratando de evitar descuadres y/o errores de formato que impidan una correcta lectura de los textos y visualización de las imágenes.

Espero que este periodo de transición no se alargue demasiado en el tiempo. Mientras tanto, espero disculpéis los posibles problemas que pudieran aparecer.

Por supuesto, si detectáis cualquier problema o tenéis alguna sugerencia/crítica sobre los cambios realizados no dudéis en poneros en contacto conmigo a través de cualquiera de los canales disponibles (comentarios, email, foro, twitter o google+).

Muchas gracias.

Como ya indicaba en el artículo anterior, aunque pensaba publicar este segundo volumen como un documento independiente, suplementario al que ya había publicado, finalmente he decidido aunar todo el contenido en un solo documento. Aprovechando esta segunda recopilación he remaquetado todo el contenido para intentar dar al curso una forma mucho más homogénea y parecida a un libro técnico, y así alejarlo un poco de la simple recopilación de artículos que suponía la primera parte publicada. Adicionalmente, he modificado un poco el aspecto visual, he corregido algunas erratas que me habéis ido comunicando, y he sustituido todas las imágenes por su versión a tamaño completo para mejorar su visualización y facilitar la lectura. Espero que todos estos cambios hagan de este documento un recurso de más valor para todos.

El sistema de donaciones para su adquisición se mantiene a través de PayPal. La donación mínima pasará a ser de 1,50 euros. Espero entendáis y disculpéis este pequeño incremento, pero el libro tiene muchísimo trabajo detrás y creo sinceramente que os merecerá la pena disponer de esta versión completa y revisada del curso, en vez de contar con dos documentos independientes.

Podéis consultar el índice completo del curso, descargar un fragmento de muestra del documento, y acceder al sistema de donación desde la página principal del proyecto, o desde el botón “Donar” disponible al final de este artículo.

Muchas gracias a todos por vuestros comentarios de ánimo, vuestro apoyo, y vuestra paciencia.

Curso de Programación Android en PDF

¿Te ha sido de utilidad el Curso de Programación Android? ¿Quieres colaborar de forma económica con el proyecto? Puedes contribuir con cualquier cantidad, unos céntimos, unos euros, cualquier donación será bienvenida. Si tu donativo es superior a 1.50 euros recibirás como agradecimiento un documento en PDF con todos los artículos del primer y segundo volumen del curso. Muchas gracias!

Más información:

• ¿Por qué donar?
• Indice de contenidos y capítulo de muestra
• Preguntas frecuentes

Comienza entonces la cuenta atrás para publicar la segunda parte del curso en formato PDF. Aunque pensaba publicar este segundo volumen como un documento independiente, suplementario al que ya había publicado, finalmente he decidido aunar todo el contenido en un solo documento. Aprovechando esta segunda recopilación he remaquetado todo el contenido para intentar dar al curso una forma mucho más homogénea y parecida a un libro técnico, y así alejarlo un poco de la simple recopilación de artículos que suponía la primera parte publicada. Adicionalmente, he modificado un poco el aspecto visual, he corregido algunas erratas que me habéis ido comunicando, y he sustituido todas las imágenes por su versión a tamaño completo para mejorar su visualización y facilitar la lectura. Espero que todos estos cambios hagan de este documento un recurso de más valor para todos.

El sistema de donaciones para su adquisición se mantiene a través de PayPal, siento no haber podido habilitar finalmente el mecanismo de transferencia bancaria. La donación mínima pasará a ser de 1,50 euros. Espero entendáis y disculpéis este pequeño incremento, pero el libro tiene muchísimo trabajo detrás y creo sinceramente que os merecerá la pena disponer de esta versión completa y revisada del curso, en vez de contar con dos documentos independientes.

Estoy en pleno proceso de revisión del documento, en unos días publicaré un fragmento de muestra para que podáis comprobar su nuevo aspecto, y en algo menos de 2 semanas estará disponible el documento final.

En definitiva, siento la larga espera para ver publicada esta segunda parte del curso, pero espero que el resultado final compense toda vuestra paciencia.

Saludos.