Comunicación Android - Base de datos (Windows)

Volver a la página de Inicio

=Introduccion=

En este tutorial se va a explicar como enviar datos desde un celular o tablet con sistema operativo Android a una base de datos. Debido a que no es recomendable establecer una conexión directa entre el dispositivo y la base de datos la comunicación se realizara por medio de un servidor web. En la primera parte se mostrara el proceso de instalación y configuración de PostgresSQL, un sistema de bases de datos muy poderoso y que además es software libre. Después se pasara a instalar Apache que permite que el computador funcione como servidor web. Para establecer la comunicación entre el servidor Apache y la base de datos Postgres se hace uso del lenguaje PHP. Este lenguaje permite que un servidor web ejecute tareas en respuesta a acciones del usuario de la página web o acciones preestablecidas cuando se está cargando la página, además tiene una biblioteca que permite el uso de sentencias SQL (Structured Query Language) para la comunicación con PostgreSQL. Por último se mostrará como enviar datos desde una aplicación android al servidor web para que este los redireccione a la base de datos. Es posible asignarle un dominio al servidor Apache para que se pueda acceder desde cualquier computador con internet pero es un proceso complejo e implica la configuración de la red en la que se encuentra el computador, por está razón en este tutorial nos limitaremos a realizar pruebas dentro de una red LAN, es decir que tanto el computador como el dispositivo Android se deben encontrar dentro de la misma red y el mismo router.

Aplicación de prueba

Para la prueba del sistema se va a simular una aplicación en el dispositivo android que va a capturar una medición de un sensor y la va enviar a la base de datos. Se asume que junto a la medición también se va a enviar la posición del dispositivo (latitud y longitud), la fecha de la medición y el número del dispositivo (Los datos enviados seran inventados y no corresponderan a mediciones hechas por el dispositivo). En la base de datos se tendran dos tablas, una para los dispositivos y otra para las mediciones. Solo los dispositivos registrados pueden enviar datos a la base de datos. Debajo se muestra un ejemplo de las dos tablas con registros. La tabla de mediciones contiene una columna adicional, id, que coloca un número diferente a cada medición que se añada.

=Base de datos PostgreSQL=

Instalación de PostgreSQL
Descargue la versión 9.1.4 para windows en el siguiente link. En el instalador siga las siguientes instrucciones:


 * 1) Iniciar instalador
 * 2) Especificar directorio (Dejar predeterminado C:\Archivos de programa\PostgreSQL\9.1)
 * 3) Seleccionar directorio donde se van a almacenar los datos (Dejar predeterminado - C:\Archivos de programa\PostgreSQL\9.1\data)
 * 4) Proporcionar contraseña de superusuario y del servicio
 * 5) Seleccionar puerto en el que el servidor debera escuchar (Si se puede dejar predeterminado 5432)
 * Nota: Hay que verificar que el puerto no este siendo usado por otra aplicación. Para esto abra el command prompt de windows(Inicio->Todos los programas->Accesorios->Símbolo del sistema) y digite netstat -o -a. Con este comando se despliega información de los puertos del computador. Verifique que el puerto seleccionado no tiene ningún proceso asignado. Cuando una aplicación está utilizando un puerto se le asigna un PID. Se puede saber que aplicación está utilizando el puerto buscando el PID en la pestaña de procesos del administrador de tareas (ctrl+alt+supr). Si alguna aplicación está utilizando el puerto puede detenerla para que deje el puerto libre asegurándose de que no lo va a volver a tomar o seleccionar un puerto que este libre.
 * 1) Seleccionar configuración regional Spanish - Colombia.
 * 2) Instalarlo.
 * 3) Finalizar la instalación iniciando el stack-builder.
 * 4) Seleccionar la instalación previa (postgres9.1) y dara click en siguiente.
 * 5) En la pestaña database drivers se pueden bajar los siguientes drivers:
 * 6) * Npgsql - permite que cualquier aplicación .net se conecte a PostgreSQL
 * 7) * pgJDBC - permite que programas java se conecten a PostgreSQL
 * 8) * PgOleDB - provee una capa de comunicación entre microsoft ADO y postgres
 * 9) * psqlODBC(OpenDatabaseConectivity) - es una API para comunicarse con la base de datos
 * Si no está instalado seleccionar psqlODBC o los demás si se necesitan.

Creación de la base de datos
En los siguientes pasos se creara la base de datos y las tablas que la componen. La comunicación con el servidor de base de datos se puede realizar mediante la consola psql (Inicio->Todos los programas->PostgreSQL9.1->SQL shell) o mediante la herramienta gráfica pgAdminIII (Inicio->Todos los programas->PostgreSQL9.1->pgAdminIII). Para la creación de la tabla utilizaremos pgAdmin. En la siguiente gráfica se muestra el explorador de objetos con una indicación de los pasos más importantes que se explican con más detalle debajo:




 * 1) Abrir pgAdminIII
 * 2) En el panel izquierdo (Object Browser) seleccione la pestaña de servidores
 * 3) De click derecho en PostgreSQL 9.1(localhost:5432) y seleccione connect. Se le pedirá la clave que introdujo en el proceso de instalación. Si el proceso de instalación se hizo de forma correcta la conexión sera exitosa.
 * 4) De click derecho en la pestaña de bases de datos y seleccione Nueva base de datos.
 * 5) En la ventana que aparece rellene los campos como se muestra a continuaciòn dependiendo de la pestaña, si no se específica el campo déjelo en blanco o con el valor predeterminado:
 * 6) * Propiedades
 * Name: sensores
 * Owner: postgres
 * 1) * Definición
 * Tablespace: default
 * 1) Al dar click en OK aparecera una pestaña con el nombre sensores. En esta base de datos crearemos la tabla de mediciones y de dispositivos.
 * 2) Abra la pestaña sensores->Schemas->public
 * 3) En la pestaña de tablas de click derecho y seleccione nueva tabla
 * 4) Coloque la siguiente información en las pestañas del cuadro de diálogo que aparece:
 * 5) * Propiedades
 * Name: dispositivos
 * Owner: postgres
 * 1) * Definición
 * Tablespace: pg_default
 * La tabla dispositivos contiene las columnas identificacion y nombre. A continuación se añaden.
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: identificacion
 * Data type: integer
 * Definición
 * Seleccionar Not Null
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: nombre
 * Data type: char varying
 * Length: 50
 * Definición
 * Collation: pg_catalog."default"
 * En una tabla la llave primaria define una columna o un grupo de columnas que se garantiza que van a tener un valor único en cada uno de los registros (Ej. la cédula de una persona). A continuación definiremos la columna identificacion como la llave primaria de la tabla dispositivos.
 * 1) * Limitaciones (Constraints):
 * Seleccionar Llave primaria y dar click en añadir.
 * Propiedades
 * Name: dispositivo_pk
 * Columnas
 * Columna: identificacion -> Luego añadir y dar click en ok.
 * 1) Dar click en OK -> La tabla se podrá ver y editar en la pestaña de tablas.
 * Ahora se creara la tabla de mediciones:
 * 1) En la pestaña de tablas de click derecho y seleccione nueva tabla
 * 2) De igual forma que en la sección anterior llene los campos en cada una de las pestañas como se específica a continuación:
 * 3) * Propiedades
 * Name: mediciones
 * Owner: postgres
 * 1) * Definición
 * Tablespace: pg_default
 * La tabla dispositivos contiene las columnas dispositivo, latitud, longitud, magnitud, fecha e id. En los siguientes pasos se añaden.
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: dispositivo
 * Data type: integer
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: latitud
 * Data type: double precision
 * Definición
 * Seleccionar Not Null
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: longitud
 * Data type: double precision
 * Definición
 * Seleccionar Not Null
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: magnitud
 * Data type: double precision
 * Definición
 * Seleccionar Not Null
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: fecha
 * Data type: timestamp without time zone
 * 1) * Columnas -> Añadir columna
 * Propiedades
 * Name: id
 * Data type: serial (Es un tipo integer que se incrementa automáticamente cada vez que se inserta un registro)
 * Definición:
 * Seleccionar Not Null
 * Para esta tabla definiremos la columna id como la llave primaria y la columna dispositivo como la llave foránea. Este tipo de llave permite asociar esta columna a una columna en otra tabla. En este caso se asociara la columna dispositivo con la columna identificación de la tabla de dispositivos. De esta forma solo se podrán añadir mediciones de dispositivos que esten registrados en la tabla de dispositivos.
 * 1) * Limitaciones (Constraints):
 * Seleccionar Primary Key y dar click en añadir.
 * Propiedades
 * Name: mediciones_pk
 * Columnas
 * Seleccionar la columna id -> Luego añadir y dar click en ok.
 * 1) * Limitaciones (Constraints)
 * Seleccionar Foreign Key y dar click en añadir.
 * Propiedades
 * Name: dispositivo_fk
 * Columnas
 * Columna local: dispositivo
 * Referencia: identificacion
 * Añadir y dar click en OK.
 * 1) Dar click en OK para crear la tabla.

Las tablas se deben visualizar de la siguiente forma en el explorador de objetos:



Comandos SQL e inserción de registros
Ahora se van a añadir unos registros a las tablas que se crearon en la sección anterior. La inserción se puede realizar desde pgAdmin con una interfaz gráfica o mediante comandos SQL desde la consola psql. Debido a que los datos que se envían desde el celular se encapsulan en comandos SQL se va a utilizar la consola para familiarizarse con el lenguaje. Para abrir la consola seleccione la pestaña de la base de datos sensores y después en el menu Plugins seleccione PSQL console.



En la consola digite  para ver las tablas correspondientes a la base de datos sensores. Se deberá ver lo siguiente:



Primero vamos a añadir registros a la tabla de dispositivos. Para esto introduzca el siguiente código y presione enter después de cada sentencia: sensores-# INSERT INTO dispositivos("identificación","nombre") VALUES(103,"samsung"); sensores-# INSERT INTO dispositivos("identificación","nombre") VALUES(205,"motorola");

Ahora introduzca los siguiente registros a la tabla de mediciones: sensores-# INSERT INTO mediciones("dispositivo","latitud","longitud","magnitud","fecha","id") VALUES(103,1,2,3,"2005-01-02 12:30:00",default); sensores-# INSERT INTO mediciones("dispositivo","latitud","longitud","magnitud","fecha","id") VALUES(205,1,2,3,"2010-05-01 23:30:00",default); sensores-# INSERT INTO mediciones("dispositivo","latitud","longitud","magnitud","fecha","id") VALUES(103,1,2,3,"2011-03-01 14:00:00",default); sensores-# INSERT INTO mediciones("dispositivo","latitud","longitud","magnitud","fecha","id") VALUES(103,2.5,67,5,"2011-03-01 14:00:00",default); sensores-# INSERT INTO mediciones("dispositivo","latitud","longitud","magnitud","fecha","id") VALUES(205,40.7,30.6,45,"2005-01-02 12:30:00",default);

Para verificar que los dipositivos y las mediciones han sido añadidas correctamente utilice las siguientes sentencias: sensores-# SELECT * FROM dipositivos; sensores-# SELECT * FROM mediciones;

Deberá ver en la consola lo siguiente:



Además de añadir registros y de verlos en las tablas se pueden hacer búsquedas selectivas, borrar registros y operaciones mucho más complejas. En este link se puede encontrar la lista completa de comandos.

=Instalación de servidor web Apache=

Instalación

 * 1) Desactive el firewall de windows y cualquier servicio de servidor que se este ejecutando, como Skype, PostgreSQL o cualquier otra aplicación de mensajería instantánea. Cuando el servidor se instale y este funcionando se pueden volver a activar sin ningún problema.
 * 2) En el siguiente link baje el instalador para windows de la versión 2.2.22 con ssl (httpd-2.2.22-win32-x86-openssl-0.9.8t.msi) y ejecutelo. En el instalador introduzca la información que se específica a continuación:
 * 3) Cuando le pida información sobre el servidor introduzca en el dominio de red y el nombre del servidor un nombre cualquiera. En el campo de email puede colocar su email. Por último habilite el servicio para todos los usuarios en el puerto 80. Como se realizó en el proceso de instalación de PostgreSQL puede verificar que el puerto no está siendo utilizado por otra aplicación mediante el comando netstat -o -a en el command prompt.
 * Apache1.png
 * 1) En la siguiente ventana seleccione la instalación avanzada.
 * Apache2.png
 * 1) Seleccione todos los archivos disponibles para la instalación. También cambie el directorio de instalación al disco local C y el nombre a apache2.2, esto se debe hacer para evitar conflictos por los espacios en el nombre de la carpeta de Archivos de programa.
 * Apache3.png
 * 1) Por último inicie la instalación.
 * Apache4.png
 * 1) Una vez terminada de click en finalizar y podrá ver en la barra de tareas de windows un nuevo ícono correspondiente al servidor apache. Si da click derecho en el ícono puede abrir el monitor del servicio. Si la instalación fue exitosa el servicio estará corriendo sin ningún problema.
 * 2) Como última prueba para verificar que el servidor está corriendo correctamente abra el navegador de internet, digite en la barra de direcciones localhost y presione enter. Si aparece it works! o If you can see this, it means that the installation of the Apache web server software on this system was successful la instalación fue exitosa.

Página de prueba
Para familiriazarse con el lenguaje html y para las pruebas de comunicación con la base de datos se creara una página web básica que en principio solo desplegara un título y una frase pero después se le añadiran funciones para que muestre información de la base de datos.

1. Abra el bloc de notas y copie el siguiente código:

  Conexión a base de datos sensores     



Conexión a base de datos sensores  En esta página se probara una conexión a la base de datos sensores





2. Guarde el archivo con el nombre sensores.htm en la carpeta C:\apache2.2\htdocs. En esta carpeta se deben guardar todos los archivos que puede compartir el servidor.

3. Abra un navegador de internet y digite en la barra de direcciones localhost:sensores.htm.La siguiente imagen muestra la página que se ha creado:



Añadir contraseña al servidor
Para añadirle seguridad evitar que cualquier persona entre al servidor se le va a asignar una contraseña, para esto realice lo siguiente:

1. Abra el command prompt (inicio->Todos los programas->Accesorios->Símbolo del sistema) y dirijase a la carpeta bin en la carpeta de instalación de apache: cd "C:\apache2.2\bin"

2. Utilice el siguiente comando para crear un usuario y su respectiva contraseña: htpasswd -c "C:\Documents and Settings\\my_password_file.txt"  Reemplaze  por el usuario de la sesión en la que esta y <Nombre de usuario servidor> por el nombre usuario del servidor. Cuando entre el comando digite la contraseña que quiere utilizar. Hecho esto se creara el archivo de contraseña.

3. Para añadir la contraseña al directorio donde se guardan los archivos del servidor (c:\apache2.2\htdocs) abra el bloc de notas y pegue las siguientes instrucciones: AuthType Basic AuthName "Esto es un area privada, por favor registrese"

AuthUserFile "c:\Documents and Settings\<Nombre de usuario windows>\my_password_file.txt" AuthGroupFile /dev/null

<Limit GET POST PUT> require valid-user </Limit>

Guarde el archivo en la carpeta raíz del servidor (c:\apache2.2\htdocs) sin nombre y con la extensión .htaccess. Para evitar que el bloc de notas lo guarde como un .txt escriba el nombre entre comillas dobles (".htaccess").

4. Abra un navegador de internet y digite en la barra de direcciones localhost/sensores.htm. El navegador deberá solicitarle un nombre de usuario y contraseña para acceder a la página.

=Comunicación Apache - Postgres con PHP=

Instalación y configuración de PHP
PHPIniDir "c:/PHP/" Loadfile "C:\php\php5ts.dll" Loadfile "C:\php\libpq.dll" LoadModule php5_module "c:/PHP/php5apache2_2.dll" AddHandler application/x-httpd-php .php AddHandler application/x-httpd-php-source .phps
 * 1) Bajar el archivo zip - VC9 x86 Thread Safe de la versión 5.4.4.
 * 2) Extraer los ficheros en el directorio c:\php o en cualquier directorio que no contenga espacios.
 * 3) Añadir C:/php a la variable de entorno PATH de windows. Esto permite que este disponible para el servidor u otros programas que quieran usar php.
 * Para esto abra el explorador de windows y en Mi PC de click derecho y elija Propiedades. En la ventana que aparece seleccione Variables de entorno en la pestaña de Opciones avanzadas seleccione Variables de entorno.
 * Php1.png
 * En la ventana que aparece seleccione la variable PATH y de click en modificar.
 * Php2.png
 * Añada el directorio ''C:/php' y de click en aceptar 2 veces.
 * 1) Copiar c:\php\php.ini-production y pegarlo en el mismo directorio con el nombre php.ini.
 * 2) Abrir php.ini con el bloc de notas.
 * 3) Coloquele a la variable doc_root el valor c:/apache2.2/htdocs. (Utilizar Edición ->Buscar en el menu del bloc de notas)
 * doc_root = "c:\apache2.2\htdocs"
 * 1) Ahora se va a añadir php al servidor apache. Diríjase al directorio c:\apache2.2\conf y a abra con el bloc de notas el archivo httpd.conf.
 * 2) En la parte donde se cargan los módulos añada los siguiente y guarde el archivo:
 * 1) BEGIN PHP INSTALLER EDITS - REMOVE ONLY ON UNINSTALL
 * 1) END PHP INSTALLER EDITS - REMOVE ONLY ON UNINSTALL
 * 9. Reinicie el servidor apache
 * 10. Para probar que PHP ha sido añadido correctamente al apache abra el bloc de notas y pegue el siguiente código:

<?Php phpinfo ?>
 * 11. Guarde el documento como prueba.php en la raiz del servidor apache (c:\apache2.2\htdocs).
 * 12. Abra el navegador de internet y en la barra de direcciones digite localhost/prueba.php. Si sale una página con toda la información de la versión de PHP instalada la instalación fue exitosa. Si desea realizar una configuración más específica o tiene problemas en la instalación en el archivo install.txt en la carpeta c:\php se encuentra información detallada sobre el proceso de instalación.

Añadir biblioteca de PostgreSQL a PHP
Ahora que se ha añadido PHP a apache se van a añadir las bibliotecas para la comunicación con PostgreSQL.


 * 1) Abra el archivo php.ini con el bloc de notas.
 * 2) Modifique el valor de la variable extension_dir para que apunte a C:\php\ext. Si la variable está comentada borre el punto y coma. En este directorio se debe encontrar la biblioteca php_pgsql.dll que trae todas las funciones para comunicarse con PostgreSQL.
 * extension_dir = "C:\php\ext"
 * 1) Abajo de donde se modifica está variable se encuentra una sección que se llama Dynamic Extensions, allí se encuentran todas las extensiones que se pueden añadir. Busque la línea que dice ;extension=php_pgsql.dll y descoméntela.
 * 2) Guarde el archivo y reinicie el servidor.
 * 3) Al cargar la página creada anteriormente prueba.php debe aparecer un bloque de información sobre pgsql:


 * Si se tienen problemas al añadir las bibliotecas en este link se encuentran algunas opciones para solucionar el problema.

Prueba conexión Apache-PostgreSQL
Se va a modificar el archivo sensores.htm que creamos en la sección anterior para poder ver la información de las tablas dispositivos y mediciones de nuestra base de datos sensores.

1. Abra el archivo sensores.htm con el bloc de notas. (c:\apache2.2\htdocs\sensores.htm).

2. Reemplace el comentario por el siguiente código. <?php //Cadena de conexión con postgresql $cadena = " host='localhost' port='5432' dbname='sensores' user='<usuario(predeterminado postgres)>' password='<contraseña>' "; //usar función pg_connect $con = pg_connect($cadena) or die("Error de conexión." . pg_last_error); echo "Conexión exitosa a base de datos "; //BÚSQUEDA DE DISPOSITIVOS //Consulta sql $sql = "SELECT * FROM dispositivos"; //Ejecutar sentencia sql con pg_query $result = pg_query($sql) or die ("Error query" . pg_last_error); //Obtener número de resultados con pg_num_rows $cont = pg_num_rows($result); //Recorrer con while los resultados dispositivos registrados y los almacena en una tabla mediante comandos html echo " "; echo " ".$cont." dispositivos registrados. "; //BÚSQUEDA DE MEDICIONES //Consulta sql $sql = "SELECT * FROM mediciones"; //Ejecutar sentencia sql con pg_query $result = pg_query($sql) or die ("Error query" . pg_last_error); //Obtener número de resultados con pg_num_rows $cont = pg_num_rows($result); //Recorrer con while los resultados dispositivos registrados y los almacena en una tabla echo " "; echo " ".$cont." mediciones registradas. "; pg_close;

//echo "<SCRIPT language='JavaScript'> "; ?>


 * En la variable $cadena cambie los valores y <contraseña> por los valores que coloco en la creación de la base de datos.

3. Guarde el archivo cambiándole la extensión a '.php' ('sensores.php') en la carpeta raiz del servidor apache.

4. Abra el navegador de internet y digite en la barra de direcciones 'localhost/sensores.php'.




 * Explicación del código:
 * El código que acabamos de añadir está encerrado en las etiquetas '<?php' y '?>'. El servidor primero ejecuta todas las sentencias 'php', estás sentencias ejecutan tareas y dependiendo de los resultados colocan información en código 'html'. Cuando todo el código 'php' ha sido ejecutado se tiene una página con solo código 'html' que es enviada por el servidor al cliente (nuestro navegador de internet). En el código que añadimos anteriormente se están utilizando funciones para la comunicación en el siguiente orden:


 * 1) pg_connect($con): Establece la conexión con la base de datos que es especificada en la variable '$con'. En esta variable se específica el host, el puerto, la base de datos, el usuario y la contraseña.
 * 2) pg_query($sql): está función ejecuta sentencias SQL en la base de datos. La función devuelve los resultados de la sentencia si esta los tiene.
 * 3) pg_num_rows($result): devuelve el número de filas en el resultado obtenido.
 * 4) pg_fetch_array($result,null,PGSQL_ASSOC): realiza una iteración en el conjunto de filas de resultados, devolviendo la siguiente fila cada vez que se ejecuta.
 * 5) pg_close: cierra la conexión con la base de datos.
 * En este link puede encontrar información detallada sobre las funciones de que dispone la biblioteca.


 * La función 'echo' se usa para colocar texto en el código 'html' de la página. También se hace uso de las etiquetas para creación de tablas de 'html'. Con las etiquetas ' ' se define una tabla. Con ' ' y ' ' se define el nombre de la tabla . Con ' ' y ' ' se establece lo que va a ir en cada fila. Para definir el texto en cada celda se utilizan las etiquetas ' y ' ' con la diferencia de que la última es utilizada para los títulos de las columnas. Mediante una setencia while se itera sobre cada uno de los registros obtenidos de la base de datos. Mediante las etiquetas anteriores cada uno de estos registros es colocado en la tabla.


 * Por último es necesatio cambiar la extensión del archivo a '.php' para que el servidor reconozca que van a haber sentencias 'php' que deben ser ejecutadas primero antes de enviar el código al cliente.

=Comunicación Base de datos - Android mediante servidor web=

Transferencia de datos a base de datos desde servidor web
Para que el servidor transfiera los datos que son enviados desde Android es necesario crear un archivo que reciba la información y la transmita a la base de datos. Para esto abrá el bloc de notas y copie el siguiente código:

<?php //Activar detección de errores ini_set('display_errors',1); error_reporting(E_ALL); //Recupera la información enviada en la solicitud http y la almacena en la variable $json que depués es decodificada en un objeto JSON. $json = file_get_contents('php://input'); $obj = json_decode($json);

//Establece conexión con la base de datos $cadena = " host='localhost' port='5432' dbname='sensores' user='<usuario (predeterminado postgres)>' password='<contraseña>' "; $con = pg_connect($cadena) or die('Cannot connect to the DB'); //Genera la solicitud SQL con los valores enviados desde Android, los envía y cierra la conexión $sql = "INSERT INTO mediciones(\"dispositivo\",\"latitud\",\"longitud\",\"magnitud\",\"fecha\",\"id\")". "VALUES('".$obj->{'Dispositivo'}."','".$obj->{'Latitud'}."','".$obj->{'Longitud'}."','".$obj->{'Magnitud'}."','".		$obj->{'Fecha'}."',default)"; $result = pg_query($sql) or die ("Error query" . pg_last_error); pg_close($con); ?>

No olvide cambiar los valores de y <contraseña> en la variable $cadena. Después guarde el archivo con el nombre sendData.php en el directorio raíz del servidor. En la siguiente sección veremos que en el dispositivo con Android la información es embebida en un objeto JSON (JavaScript Object Notation). Este tipo de objeto se usa para la transferencia de datos pequeños por internet y guarda los datos como parejas de datos Nombre-Valor en formato de texto. En el archivo anterior se recupera la información enviada mediante el comando file_get_contents('php://input') y luego es decodificada con json_decode($json), esta decodificación almacena cada valor en un arreglo refenciado por su respectivo nombre. En la siguiente parte se establece la conexión con el servidor de base de datos y después se ejecuta la sentencia INSERT con los valores del objeto JSON mediante la función pg_query($sql). Depués de ejecutar la sentencia se cierra la conexión. Es importante ver que este archivo no genera una página web ya que ni siquiera tiene código html, por lo que el servidor ejecuta las tareas y no hace nada más.

Ahora que se ha creado este archivo es necesario crear la aplicación en el dispositivo para poder probarlo.

Envío de datos a servidor web desde Android
En eclipse cree un nuevo proyecto Android especificando la versión del sistema operativo que se va a utilizar. La aplicación diseñada se ha probado en un dispositivo con la versión 2.2 de Android. La interfaz de la aplicación que se va a crear es la siguiente: Se puede ver hay 5 campos correspondientes a los valores dispositivo, latitud, longitud, magnitud y fecha de la tabla mediciones. También se utiliza un botón para enviar los datos. Se debe modificar el archivo 'main.xml' que se encuentra 'carpetaDelProyecto/res/layout/main.xml'. Los 11 elementos de la figura anterior se embeben en un 'Linear Layout' vertical. El código de cada una de las parejas 'Etiqueta-CampoDeTexto' se dentro de un 'Layout horizontal' con un 'TextView' y un 'EditText'. El siguiente es el código completo de la interfaz:

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" >

<LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" >

<TextView android:id="@+id/textDisp" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="Dispositivo" />

<EditText android:id="@+id/editTxDisp" android:layout_width="wrap_content" android:layout_height="wrap_content" android:ems="10" >

<requestFocus /> </EditText>

</LinearLayout> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" >

<TextView android:id="@+id/textLat" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="Latitud" />

<EditText android:id="@+id/editTxLat" android:layout_width="214dp" android:layout_height="wrap_content" android:layout_weight="0.08" >

<requestFocus /> </EditText>

</LinearLayout> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" >

<TextView android:id="@+id/textLong" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="Longitud" />

<EditText android:id="@+id/editTxLong" android:layout_width="wrap_content" android:layout_height="wrap_content" android:ems="10" >

<requestFocus /> </EditText>

</LinearLayout> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" >

<TextView android:id="@+id/textMag" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="Magnitud" />

<EditText android:id="@+id/editTxMag" android:layout_width="wrap_content" android:layout_height="wrap_content" android:ems="10" >

<requestFocus /> </EditText>

</LinearLayout> <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" >

<TextView android:id="@+id/textFecha" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_weight="1" android:text="Fecha" />

<EditText android:id="@+id/editTxFecha" android:layout_width="wrap_content" android:layout_height="wrap_content" android:ems="10" >

<requestFocus /> </EditText>

</LinearLayout>

<Button android:id="@+id/button1" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Enviar" />

</LinearLayout>

Como la aplicación se va a conectar a internet para enviar los datos se debe añadir lo siguiente en el archivo de manifiesto: <uses-permission android:name="android.permission.INTERNET"></uses-permission> También recomiendo añadir en la pestaña de manifiesto '<manifest xmlns:android="http://schemas.android.com/apk/res/android" ...>' el siguiente código: android:installLocation="preferExternal" Esto se utiliza para que la instalación de la aplicación se realice en la memoria externa y no en la memoria interna del dispositivo. Solo se debe utilizar si el dispositivo cuenta con una.

Ahora se va a modificar la actividad principal que es la que se va a encargar de tomar los valores en los campos de texto de la interfaz y enviarlos al servidor web. Realice los siguientes pasos:

1. Entre la declaración de la actividad y el método 'onCreate' cree las siguientes variables: private EditText 	etDispositivo; private EditText 	etLongitud; private EditText 	etLatitud; private EditText 	etMagnitud; private EditText 	etFecha; private Button	 	bEnviar; private String		dispositivo; private String   	latitud; private String		longitud; private String		magnitud; private String		fecha; private String host = "Dirección IP"; private String username = " "; private String password = "<contraseña>";

Las variable EditText se van a utilizar para obtener el texto en los campos EditText. Las variables String para almacenar los valores obtenidos anteriormente. También se crea una variable tipo Button para añadir un evento al botón en la interfaz cuando este es presionado, en nuestro caso se enviara la información cuando el usuario presione el botón enviar. Las variables host, username y password deben modificarse con los valores correctos correspondientes al servidor web. Para consultar la dirección ip del servidor web en el 'command prompt' digite 'ipconfig'.

2. Reemplace el código dentro del método onCreate por el siguiente:

super.onCreate(savedInstanceState); setContentView(R.layout.main); etDispositivo = (EditText) findViewById(R.id.editTxDisp); etLatitud = (EditText) findViewById(R.id.editTxLat); etLongitud = (EditText) findViewById(R.id.editTxLong); etMagnitud = (EditText) findViewById(R.id.editTxMag); etFecha = (EditText) findViewById(R.id.editTxFecha); bEnviar = (Button) findViewById(R.id.button1); bEnviar.setOnClickListener(new OnClickListener{       	public void onClick(View view){        		dispositivo = etDispositivo.getText.toString;        		latitud = etLatitud.getText.toString;        		longitud = etLongitud.getText.toString;        		magnitud = etMagnitud.getText.toString;        		fecha = etFecha.getText.toString;        		postData;        	}        });

En la primera parte con el método setContentView establecemos la interfaz de usuario con el archivo main.xml. Después asociamos cada uno de los campos EditText y el botón de la interfaz de usuario con variables locales de la actividad. Al botón se le añade un evento cuando es activado. En el método onClick se guardan cada uno de los valores de los campos de texto en variables tipo String y depués se llama al método postData que definiremos en el siguiente paso.

3. Después del método onCreate copie el siguiente código:

public void postData{ try{ JSONObject jsonObj = new JSONObject; jsonObj.put("Dispositivo", dispositivo); jsonObj.put("Latitud", latitud); jsonObj.put("Longitud", longitud); jsonObj.put("Magnitud", magnitud); jsonObj.put("Fecha", fecha); String url = "http://"+host+"/sendData.php"; // Create the POST object and add the parameters HttpPost httpPost = new HttpPost(url); StringEntity entity = new StringEntity(jsonObj.toString, HTTP.UTF_8); entity.setContentType("application/json"); httpPost.setEntity(entity); HttpClient client = new DefaultHttpClient; AuthScope as = new AuthScope(host, 80); UsernamePasswordCredentials upc = new UsernamePasswordCredentials(	               username, password); ((AbstractHttpClient) client).getCredentialsProvider .setCredentials(as, upc); HttpResponse response = client.execute(httpPost); }catch(Exception e){ Log.e(TAG,"Error: "+e.getMessage); Toast.makeText(this, "Request failed: " + e.toString,                   Toast.LENGTH_LONG).show; }   }

En la primera parte se crea un objeto JSON y se le añaden los valores almacenados en las variables dispositivo, latitud, longitud, magnitud y fecha con su respectiva etiqueta. El método post se usa para enviar información embebida en una URI al servidor. La clase HttpPost se encarga de establecer esta solicitud. Una entidad utiliza una cabecera y un cuerpo, y se utiliza para enviar información en las solicitudes http. La clase StringEntity define una entidad y en este caso le estamos colocando los valores del objeto JSON. Después se define en la cabecera el tipo de contenido y por último se añade la entidad a la solicitud POST.

Después de tener completamente definida la solicitud se crea el cliente con la clase HttpClient que se va a encargar de enviar la solicitud POST. Se define la dirección ip y el puerto del host además del usuario y la contraseña. Por último se ejecuta la solicitud mediante el método execute. En caso de que haya alguna excepción es atrapada y se despliega su respectivo mensaje en la pantalla mediante el método Toast.makeText.

4. Para probar la aplicación se deben conectar el dispositivo android y el servidor al mismo router en la misma red. Se debe verificar que la variable host en la aplicación Android contiene la dirección ip correcta del servidor en la red. Se pueden colocar valores aleatorios en los campos siempre y cuando correspondan con los tipos establecidos en la base de datos. También debemos recordar que el número de dispositivo debe estar registrado en la base de datos para poder registrar la medición. Por último el formato de fecha debe ser. Cuando se hayan introducido los datos se debe presionar enviar y en unos pocos segundos los datos debene estar registrados en la base de datos. Podemos verificar que el registro ha sido realizado mediante la página sensores.php que creamos anteriormente o mediante la consola del pgAdmin3 y el comando select * from .

=Bibliografía=

Tutorial pgAdmin 3 - ArPUG (Grupo de usuarios de PostgreSQL de Argentina): http://www.arpug.com.ar/trac/wiki/PgAdmin

Lista de comandos postgresql: http://www.postgresql.org/docs/9.1/static/sql-commands.html

Sitio web oficial de PostgreSQL: http://www.postgresql.org/

Funciones de la biblioteca de PostgreSQL para PHP: http://php.net/manual/en/book.pgsql.php

lifehacker Geek to Live: How to set up a personal home web server: http://lifehacker.com/124212/geek-to-live--how-to-set-up-a-personal-home-web-server

Integración de php con apache: http://www.desarrolloweb.com/articulos/1380.php

Introducción de JSON: http://www.json.org/

Hypertext Transfer Protocol -- HTTP/1.1: http://www.ietf.org/rfc/rfc2616.txt