domingo, 16 de junio de 2013

Nuestra aplicación en Android

Tener desarrollada una aplicación para FirefoxOS significa poder tenerla para otras plataformas fácilmente, como Webapp. En este artículo vamos a ver como pasar nuestra aplicación de tiradas de dados a Android con los menores cambios posibles. Aquí tenéis algunos enlaces útiles para seguir el artículo:


El primer paso que hemos de dar es descargar el entorno de programación que prefiramos para programar Android. En mi caso uso Eclipse con el plugin ADT, que podéis instalar siguiendo las instrucciones. Una vez lo tengamos creamos un proyecto nuevo en blanco y metemos nuestra aplicación HTML en el directorio "assets":


Con esto ya tenemos el código dentro del proyecto, pero todavía no mostrará nada si lo ejecutamos. Para que funcione debemos hacer dos cosas: Crear en la vista un componente de tipo WebView que nos muestre el contenido HTML y modificar el controlador principal para que cargue en dicho componente nuestra página de inicio. Lo primero es lo mas sencillo: Vamos a la carpeta "res/layout" y buscamos la plantilla principal, en mi caso "activity_main.xml". Ahí solo hay que insertar el siguiente componente:
   
<android.webkit.WebView
        android:id="@+id/webkit"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" />

Este deberá de colocarse dentro de la etiqueta raíz (en mi caso "RelativeLayout") sustituyendo cualquier otro contenido que hubiese. Nos creará el componente de tipo WebView ocupando todo el alto y ancho de la ventana principal. A continuación abrimos el código, en mi caso: "src/com.legendarya.lanzadados/MainActivity" y buscamos el método "onCreate":
   
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);

 // Código insertado para la WebApp
 WebView mWebView = (WebView) findViewById(R.id.webkit);
 mWebView.getSettings().setJavaScriptEnabled(true);
 mWebView.loadUrl("file:///android_asset/index.html");
}

La primera línea es la descripción del método, y junto a las dos siguientes (la llamada al padre y la elección de la plantilla) es el contenido que teníamos originalmente. Lo que hemos añadido son las tres últimas líneas:

  • Primero localizamos el WevView (identificado en este caso como "webkit")
  • La siguiente línea indica que el Javascript esté activado para este componente, pues por defecto no lo está y sin el la programación no funcionaría.
  • Por último se carga dentro del componente nuestra pantalla principal "index.html"
¡Listo! Solo con esto, que podemos reutilizar para otros proyectos cambiando tan solo el contenido de "assets", ya podemos ejecutar la aplicación obteniendo el siguiente resultado:


En conclusión

En este artículo hemos creado fácilmente una webapp de Android a partir de una aplicación FirefoxOS que habíamos desarrollado anteriormente. Este es el esquema que aplicaremos de ahora en adelante: Desarrollar ejemplos en FirefoxOS que se puedan portar posteriormente a otras plataformas, ahorrándonos así mucho trabajo y logrando mayor difusión. Por tanto la mayoría de los próximos artículos se centrarán simplemente en el desarrollo de webapps sobre FirefoxOS y las tecnologías que necesitamos aprender para ello.

Sin embargo de vez en cuando escribiré algún que otro artículo tanto para ver como portar la aplicación a las demás plataformas (empezando por iPhone) como para describir problemas y posibles soluciones en la compatibilidad de las diversas tecnologías, y la manera de resolverlas, como el framework LungoJS.

lunes, 10 de junio de 2013

iPhone y Android con el framework Lungo

Este blog se orienta hacia FirefoxOS, pero no pretendemos dejar a un lado otras plataformas. FirefoxOS se programa mediante HTML5 y eso significa que estas mismas apps se podrán utilizar en cualquier dispositivo, aunque no tengan tan buena integración como con FirefoxOS. Por ello una parte de este blog se dedicará a ver como adaptar nuestras aplicaciones a otros dispositivos.

Y con ese objetivo voy a presentaros Lungo, un framework de origen español para el desarrollo de aplicaciones móviles multiplataforma (iPhone, Android, Web, Blackberry,...), basado en HTML5. En un próximo artículo crearé una aplicación tanto para FirefoxOS como para Android usando este framework, que además de la integración en diferentes sistemas promete unas herramientas adaptadas a la construcción de aplicaciones móviles muy interesantes.

Por el momento os dejo con un vídeo de introducción. Es demasiado largo por que se enrollan un poco, y lo que mostrarán aquí probablemente lo veamos en próximos artículos si realmente es tan potente como promete. Pero también resulta interesante por otros comentarios a nivel de desarrollo, tecnología y dinámica de trabajo:

  Habla

sábado, 8 de junio de 2013

Programando un foro para FirefoxOS (II): Creando la base de datos

Como hablamos anteriormente, para crear un foro en el que puedan escribir diferentes usuarios desde sus móviles necesitamos de un servidor web con base de datos en el que almacenar los mensajes. En este artículo veremos como instalar un servidor web en el propio ordenador para poder hacer el desarrollo y crearemos una pequeña base de datos con phpMyAdmin.

Este artículo es innecesario para los que solo os interese la programación de móviles, y será posible hacer el resto de pasos sin necesidad de este dado que dejaré la base de datos necesaria funcionando online en mi propio servidor. En cualquier caso puede ser interesante por conocer un poco del lenguaje de consultas a bases de datos SQL.

Como siempre, aquí tenéis unos enlaces útiles para la lección:


Lo primero que hay que hacer es descargar e instalar un servidor, que en mi caso será el WAMP. Es un paquete que instala sobre Windows el servidor Apache, con bases de datos MySQL y el lenguaje de programación PHP. En definitiva, un todo en uno para montar una web dinámica. Una vez instalado y ejecutado aparecerá un icono verde en la barra de tareas:


Si en lugar de verde está en color rojo indica que el servidor no termina de arrancar, y si fuese en amarillo es el servidor de base de datos MySQL el que no se está ejecutando. Dando por hecho que todo haya ido bien, podemos abrir el navegador de internet y escribir la dirección "127.0.0.1", que es la IP local, que siempre apunta al propio ordenador. Lo que veremos será una página similar a esta:


A continuación podemos pulsar en el apartado "Tools" el enlace a phpMyAAdmin, que no es más que un interfaz de acceso a las bases de datos MySQL escrito en PHP. Desde ahí, pulsando sobre la pestaña "base de datos", podemos crear una nueva base de datos escribiendo el nombre ("foro", por ejemplo):


El "cotejamiento" es el formato en que se guardan los textos, para el que suelo usar "utf-8-general-ci" (Formato de Texto Universal de 8 Bits, útil para trabajar con distintos idiomas). Pero no es imprescindible marcarlo y se puede cambiar más adelante. Una vez creada la base de datos aparecerá en el lateral, y podremos acceder a ella para crear las estructuras de datos:


Aquí podremos ya crear las tabas, en donde empezaremos con una llamada "tema" con 5 columnas:


Las columnas que crearemos son: un identificador numérico (id), que permita asignar un número a cada tema, un campo "foro", con el identificador del foro al que pertenece, y otro "usuario" con el del autor del tema. Un campo "fecha" que indique cuando se actualizó por última vez y por último y un campo "título", de tipo texto, para el título del tema:


Los campos seran por tanto de tipo INT (número entero) excepto la fecha, que será de tipo DATETIME, y el título, que será CHAR (texto de tamaño fijo) en el que indicamos una longitud de 200 caracteres máximo. Pero además indicaremos un par de datos más en los atributos de la izquierda: La clave primaria y los índices:


En la fila del identificador (id), en la columna de índice, escogemos la opción "primary". Esto indica que el identificador (id) será único, es decir, que no habrá dos temas con el mismo número de identificador. Y también marcaremos la opción de "autoincrement", que significa que al crear un nuevo tema automáticamente escogerá para el un identificador que sea un número superior que el anterior (uno, dos, tres,...). Además pondremos los campos de foro y tema como índices. Esto le dice al gestor que podemos buscar en la tabla por dichos atributos (buscar los temas que pertenezcan a un foro, por ejemplo) y lo que hará el gestor es guardar un índice de temas ordenado por el tema al que pertenecen para acelerar las búsquedas.

Por último pulsamos "Guardar", creando así la tabla. Dependiendo de la versión de phpMyAdmin usada mostrará además el código SQL utilizado, pues al final todos estos formularios y datos introducidos no hacen mas que generar un código SQL que es como tradicionalmente se haría la creación de bases de datos. Gracias a estos programas nos ahorramos tener que saber de memoria el lenguaje SQL, pero aún así lo veremos un instante para conocerlo un poco:

CREATE TABLE IF NOT EXISTS `tema` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `foro` int(11) NOT NULL,
  `usuario` int(11) NOT NULL,
  `fecha` datetime NOT NULL,
  `titulo` char(200) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `foro` (`foro`,`usuario`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

Lo primero que quería hacer constar es lo sencillo que está creado este lenguaje, preparado para ser leído por personas fácilmente. Así por ejemplo "CREATE TABLE IF NOT EXIST" significa obviamente "Crear tabla si no existe". Otras cuestiones sobre esta instrucción:

  • Tras dicha declaración se pone el nombre de la tabla a crear. En nuestro caso "tema"
  • Los campos de la tabla se sitúan después, entre paréntesis y separados por comas
  • Para cada campo se pone primero el nombre (ej: "id"), después el tipo ("int(11)", "datetime", "char(200)"), y finalmente otros atributos, como una indicación de que no puede tomar valor nulo (NOT NULL) o que el valor se debe de incrementar automáticamente con cada nuevo elemento (AUTOINCREMENT).
  • También dentro de la tabla se indican las claves: la clave primaria (PRIMARY KEY) y los índices (KEY)
  • Finalmente, tras el paréntesis, se indica otra información de la tabla, que no voy a describir con detalle pero que en este caso es el tipo de motor que se usará para acceder, la codificación del texto y con que número comienza la clave primaria.
He de admitir que yo mismo no me se esta sintaxis de memoria, dado que la creación de tablas se hace muy de tarde en tarde y normalmente con un gestor de este tipo, pero en próximos artículos tendremos que utilizar otras instrucciones de SQL más recurrentes para la consulta y modificación de los datos que si resulta fácil acabar aprendiendo.

Esto lo comenzaremos a ver en el próximo artículo, en donde se realizará una actividad transversal con la creación de un nuevo tema que irá desde la aplicación en FirefoxOS donde se pedirán los datos, hasta la base de datos MySQL, pasando por un servicio en el servidor que reciba la orden, escrito en PHP.

sábado, 1 de junio de 2013

JSON y tipos de datos en javascript


JSON es una de las maneras de transferir información en Internet. La gran ventaja de este formato es que en realidad es código javascript y por tanto es mucho más fácil trabajar con el que con XML o simple texto plano. Aprovecharemos este artículo no solo para hablar de este formato, que usaremos en próximos artículos, sino también para conocer los tipos de datos usados en javascript y en casi cualquier otro lenguaje de programación. Los siguientes son enlaces útiles para esta lección:


Ejemplos interactivos

Antes de comenzar, en el siguiente enlace podréis encontrar unos ejemplos interactivos para la lección. Consiste en una lista de ejemplos que muestran diferentes fragmentos de código que se pueden editar y ejecutar con el botón de debajo. He creado una función llamada "mostrar_en_pantalla", que muestra el contenido que le pasemos como parámetro en el área gris de la derecha:


La idea es simplemente que según vayáis leyendo el artículo podáis probar los distintos ejemplos e intentar hacer cambios para comprobar el resultado, sobre todo a la hora de acceder a contenidos. También veremos al final del artículo que para generar la lista de ejemplos hemos usado JSON, con lo que lo usaremos como ejemplo práctico de lo visto en el artículo.

Para quien tenga curiosidad, la clave del programa está en la función "eval(código)", que es una función de javascript que ejecuta sobre la marcha, el código que le pasemos como parámetro. Así que lo que nosotros hacemos es simplemente pasarle lo que hay escrito en el área de texto.

Tipos básicos

Javascript (y por tanto JSON) permite almacenar números, textos, variables booleanas (que toman valores de verdadero y falso) y también valores nulos (null). Esta es la información básica que se utiliza en estructuras más complejas, como veremos más abajo. Pero por el momento veamos un ejemplo de cada uno de estos casos:

var variable_nula; // Una variable sin valor asignado tiene el valor null
var variable_nula2=null; // También se puede asignar directamente

var booleano=true; // Los booleanos pueden ser ciertos (true) 
var booleano2=false; // o falsos (false)

var numero=10; // Número entero
var numero2=-15.5; // Número negativo decimal
var numero3=5.5+e3; // Equivale a 5,5 x 10 elevado a 3 = 5500

var texto="Hola mundo"; // El texto se identifica por ir entre comillas

// Si el propio texto tiene comillas se le pone una barra delante
var texto2="Este texto tiene\"comillas\"";

// Se pueden meter barras (\\), tabulación (\t) y saltos de línea (\n)
var texto3="Texto con \\, tabulador:(\t) \n Esto es una nueva línea" 

Los números, como habréis visto, pueden usar el punto para usar decimales, y el guión para valores negativos, y también permiten fórmulas exponenciales para valores muy grandes o muy pequeños (ej: 10.5e+6 significa 10,5 millones).

Los textos en principio son cualquier cadena situada entre comillas dobles (") o simples ('), aunque hay varias excepciones indicadas por una barra invertida que las precede: Si hemos de escribir comillas dentro del texto deberemos anteponer una barra invertida (\") para diferenciarlas de las barras de apertura y cierre, y lo mismo si queremos escribir la barra invertida, que habremos de escribirla dos veces (\\). Las barras también nos permiten hacer saltos de línea (\n) y tabulaciones (\t).

En los ejemplos podéis probar a modificar los números y textos y comprobar el resultado.

Arrays

Un array es una lista de elementos. Pueden ser números, textos, booleanos o incluso otros arrays u objetos:

var array1=[1,2,3,4,5];

var array2=["Juan","María","Pedro","Luisa"];

var array3=[
 [1,2,3,4,5],
 ["Juan","María","Pedro","Luisa"],
 [null,false,[1,2],"Hola mundo",13.5]
];

Los arrays se acceden mediante un índice, comenzando en "0". Es decir, al primer elemento se accede mediante "array[0]", al segundo con "array[1]", al tercero con "array[2]",...

Hay un par de ejemplos de arrays, donde podéis probar a añadir más elementos y acceder a ellos con distintos índices.

Objetos

Un objeto es un elemento con varias propiedades de cualquier tipo, identificadas con etiquetas. Por ejemplo podríamos crear un objeto persona que tuviese una propiedad "nombre", de tipo texto, otra propiedad "edad", de tipo número, otra "fecha_de_nacimiento", que fuese a su vez otro objeto con las propiedades "día", "mes" y "año",...:

var persona={
 "nombre":"Juan",
 "edad":35,
 "soltero":true,
 "fecha":{
  "día":12,
  "mes":6,
  "año":1975
 },
 "amigos":["Pedro","Jose","Marta"]
}

Hay dos maneras de acceder a las propiedades de un objeto: O bien usando un punto (ej: persona.nombre), o usando corchetes (ej: persona["fecha_de_nacimiento"]). El primer método es más habitual, pero el segundo tiene usos interesantes. Podéis ver un ejemplo de esto, y probar ambas formas de acceder a las propiedades, además de añadir vuestros propios campos.

Un ejemplo de JSON

Hasta ahora hemos visto los tipos de datos de javascript, que usaremos en JSON, pero en realidad hemos hablado poco de este lenguaje en si. Para hacerlo, nada mejor que un ejemplo. Como dijimos al principio, el propio programa de ejemplos interactivos utiliza JSON para generar la lista de ejemplos. La idea es muy simple ¿como sabe el programa que ejemplos mostrar en la lista y que códigos corresponden a cada uno? Pues muy sencillo: podemos crear una estructura JSON que lo indique. En nuestro caso:

var ejemplos=[
 {
  "titulo":"Números",
  "codigo":"var numero=10;\n\nmostrar_en_pantalla(numero)"
 },
 {
  "titulo":"Decimales",
  "codigo":"var numero=10.1;\n\nmostrar_en_pantalla(numero)"
 },
 {
  "titulo":"Texto",
  "codigo":"var texto=\"Hola mundo\";"+
   "\n\nmostrar_en_pantalla(texto)"
 },
 {
  "titulo":"Texto con comillas",
  "codigo":"var texto=\"Texto con \\\"comillas\\\"\\b\";"+
   "\n\nmostrar_en_pantalla(texto)"
 },
 {
  "titulo":"Array numérico",
  "codigo":"var array_de_numeros=[1,2,3,4];\n\n// Observa "+
   "que los índices de los arrays empiezan en cero, "+
   "\n// así que el número 3 muestra el cuarto elemento"+
   "\nmostrar_en_pantalla(array_de_numeros[3])"
 },
 {
  "titulo":"Array de texto",
  "codigo":"var array_de_texto=[\"Juan\",\"María\",\"Ana\","+
   "\"Luis\"];\n\nmostrar_en_pantalla(array_de_texto[0])"
 },
 {
  "titulo":"Array de arrays",
  "codigo":"var array_de_arrays=[\n\t[1,2,3,4],"+
   "\n\t[\"Juan\",\"María\",\"Ana\",\"Luis\"],"+
   "\n\t[\"uno\",2,false,null]\n];"+
   "\n\nmostrar_en_pantalla(array_de_arrays[1][2])"
 },
 {
  "titulo":"Objeto",
  "codigo":"var persona={\n\t\"nombre\":\"Juan\",\n\t\"edad\":35"+
   "\n};\n\nmostrar_en_pantalla(persona.nombre)"
 }
];

Como podéis ver se trata de una lista de objetos en el que cada objeto tiene un título para mostrar en el menú, y un código para mostrar en el área de texto editable cuando se pulse en el elemento correspondiente de la lista.

Así que JSON simplemente permite almacenar información de una manera estructurada que luego nuestros programas podrán usar, transmitir o almacenar. En próximos artículos veremos lo útil que es esto en multitud de situaciones.