jueves, 21 de mayo de 2015

PhoneGap vs Appcelerator Titanium vs Xamarin

 El siguiente análisis se realizó con el objetivo de tener una referencia sobre las herramientas de desarrollo Mobile utilizadas por los equipos de desarrollo en la actualidad a fin de poder evaluar las virtudes y desventajas de los diferentes enfoques.

 “Podremos desarrollar aplicaciones para las diferentes plataformas  window phone, IOS , Android logrando reducir costos de construcción y  tiempos de desarrollo , pero será difícil alcanzar  el rendimiento , tamaño de las aplicaciones , la vinculación con el sistema operativo que logra el desarrollo nativo para las diferentes plataformas.”
La necesidad puntual del proyecto que se quiera llevar acabado indicara que costos estamos dispuestos a asumir.

En la actualidad hay varias herramientas para desarrollo multiplataforma cada una de ellas como una cuestión de venta indican entre líneas pequeñas “Generadores de código nativo” cuando desde el punto de vista técnico algunas no se acercan nada a lo esperado de una aplicación nativa.
En esta ocasión vamos a analizar en modo resumen la más importantes o difundidas entre comunidades de desarrollo de dispositivos móviles con sus diferentes enfoques de construcción multiplataforma existentes:
  • ·         PhoneGap
  • ·         Appcelerator  Titanium
  • ·         Xamarin

  

Phonegap



La construcción se realiza con la utilización de hitos tecnológicos como HTML, CSS, JAVASCRIPT y al momento de empaquetar para alguna plataforma utilizamos el contenedor phonegap que encapsula todo el proyecto web  en un binario para la plataforma en cuestión.

Los programadores para simular la interfaz de las diferentes plataformas utiliza CSS y para lograr una dinámica de funcionamiento se utilizan muchas librerías jquerymobile , kendo , sencha , entre otros.
Un tema importante es el hecho de que nos proporciona una librería para cada plataforma que es la encargada de interaccionar con los correspondientes SDK. 

Lo preocupante es que los desarrollos de estas librerías se realizan por separado  por lo que es probable que en alguna plataforma se pueda contar con funcionalidades que en otra no están disponibles.

Uno de los aspectos que reduce el rendimiento de las aplicaciones desarrolladas con esta herramienta es el hecho de que cada aplicación al ser utilizada referencia al engine del navegador de nuestro dispositivo para lograr ser operativa cada vez que la llamamos en nuestro teléfono, algo que claramente afecta el rendimiento de las aplicaciones.

Por otro lado en numerosos foros hablan de los problemas que manifiesta la herramienta a la hora de acceder al hardware de los dispositivos dado que para algunos dispositivos funciona de manera aceptable y para otro en muchos casos se recurre a desarrollos nativos externos para lograr alcanzar la necesidad.

Ventajas
·         Los tiempos desarrollo son más cortos en algunos casos,  en muchos casos ya tenemos una versión operativa web del producto por lo que en este caso se trabaja en adatar el frontend lo que reduce tiempos de construcción.
·         Los costos del desarrollo son más bajos comparado con el valor hora de programadores nativo mobile, la curva de aprendizaje de phoneghap para un desarrollador web es corta por utilizar los mismos hitos de desarrollo, motivo por el que quizás no tengamos que salir a contratar especialistas sino reutilizamos la mano de obra existente.
·         La curva de aprendizaje es corta.
·         Es gratis
·         Hay mucha documentación
·         El conseguir profesionales idóneos es más fácil.
Desventaja
·         Se debe trabajar con otros framework para lograr interfaces similares a la de las plataformas para la cual estamos desarrollando y por supuesto en algunos casos creamos un frontend para cada plataforma con el objetivo de lograr interfaces en armonía con la plataforma para la cual estamos desarrollando.  En pocas palabras la interfaz de las aplicaciones Android no es igual a las de iphone.
·         No tiene rendimiento nativo al pasar siempre por el engine del navegador,  al ser dependiente del navegador de nuestro equipo produce claramente una dependencia en cada ejecución con un software intermediario, en algunos casos se nota y en otro solo al iniciar.
·         Problemas a la hora de interaccionar con el hardware del teléfono.
·         En casos particulares no será posible obtener en algunos casos una misma funcionalidad para diferentes plataformas, ya lo mencionamos con anterioridad existen librerías de acceso a los sdk que evolucionan en paralelo.

Nota Final: Presenta grandes problemas a la hora de desarrollar para IOS por lo dificultoso que se vuelve lograr simular UI e funcionalidad en una aplicación web.  Recordemos que hablamos de una aplicación web encapsulada en un binario que le permite existir en un dispositivo de una plataforma determinada por lo que no podemos pedir que alcance un rendimiento nativo.  Otro problema detectado por equipos de desarrollo es el tamaño de los empaquetados que en un muchos casos difiere en mucho del generado con una herramienta nativa, lo que produce muchas veces problemas a la hora de subir a algún store por las limitaciones impuestas por cada plataforma.



Appcelerator Titanium


Esta herramienta es otra alternativa a la hora de realizar un desarrollo multiplataforma de una manera un poco más híbrida dado que el desarrollo tiene parte nativa.

Debemos  olvidar HTML , DOM, CSS y las librerías javascript desarrolladas para navegadores como jquery , molotools..etc. Uno de los puntos a favor que tiene es la capacidad de poder manipular controles nativos para las diferentes plataformas y gestionar la lógico por medio de la utilización de javascript.

El trabajo de la interfaz gráfica se realiza por medio de una librería puente entre nuestra lógica javascript y los controles nativos de las diferentes plataformas.

Nota: Es  claro que genera aplicaciones resultante con mayor performance por acercarse a un escenario hibrido (controles nativos + javascript compilado).

Como ¿?  Una vez hemos terminado la aplicación en código en Javascript, este es transformado y compilado.  Posteriormente, cuando se arranca la aplicación en el dispositivo móvil, el código se ejecuta dentro de un motor Javascript que todos los dispositivos tienen, ya sea el JavaScriptCore en iOS o Mozilla Rhino en Android/BlackBerry.
Los programadores java de seguro se sentirán mas cómodos con el entorno de trabajo dado que estaba basada en un eclipse (ide de trabajo java)  con las modificaciones necesarias para lograr la herramienta deseada.
Alguna de las cosas de las que se quejan los desarrolladores es que estas librerías puentes javascript como todo se desarrollan y mantienen por separado por lo que nuevamente podemos lograr funcionalidades para una plataforma y quizás no este disponible para otra.

Ventajas
·         Desarrollo para múltiples plataformas
·         Muchas documentaciones
·         Mejor rendimiento al ser desarrollos híbridos entre javascript y controles nativos.
·         Versión gratuita
Desventajas
·         Problemas de funcionamiento en la ide que al parecer se muere dado que utiliza muchos recursos en algunos casos.
·         Es una comunidad muy chicas de desarrolladores por lo que hay pocos ejemplos.
·         Require Mac y XCode para aplicaciones iOS


XAMARIN



La tecnologías de Xamarin nos da una muy buena alternativa para el desarrollo móvile, apoyándonos sobre la tecnología .NET (a través de mono) para mejorar la productividad de las aplicaciones que desarrollamos.



Xamarin por otro lado promueve al igual que muchas herramientas que analizamos como generador de aplicaciones nativas.
 Sera verdad ¿? Podríamos decir casi casi
Su esquema de desarrollo se base en desarrollar interfaz de usuario para cada plataforma y desarrollar  la lógica de negocio utilizando c#.
Nota: Una librería portable (PCL) es una librería cuyo código y dependencias externas pueden ser llevadas a diversas plataformas sin perder funcionalidad.
Para decirlo de una manera práctica nosotros tendremos nuestra aplicación net corriendo sobre mono runtime embebido de nuestra aplicación y para ciertas tareas tendremos comunicaciones con api nativa Android, IOS ..etc.
Entonces?  Tenemos interfaces nativas para cada plataforma y una lógica desarrollada con c# que interacciona con api nativas ios o android cuando lo necesita, pero no deja ser un ensamblado net que se comporta como un código nativo y se comunica con código nativo. 
Como lo podemos observar Xamarin corrige algunos problemas que tiene algunas herramienta como ser el hecho de que no se preocupa para estandarizar la Interfaz  dado que esto lleva a interfaces pobres y limitadas
Ventajas
·         Ide potente
·         Propone un ambiente de test  para diferentes dispositivos Tablet y teléfonos donde se puede probar el funcionamiento.
·         Genera código nativo
·         Muy buen rendimiento de las aplicaciones.
·          
Desventaja
·         Algunos desarrollados con la herramienta documentaron problemas con el tamaño del empaquetado final, como sabran todo los store fijan un tope para el espacio que puede tener una aplicación.
·         No hay mucho soporte en la red dado que es una herramienta relativa nueva.
·         Es necesario tener una mac para poder realizar la compilación para IOS
·         El ambiente de test es pago.
·         Algunos proyectos reportaron problemas en un pequeño delay al inicio de toda aplicación que es mas largo de lo común.
·         No todos los controles visuales nativos de cada plataforma se encuentran disponibles para su uso.
·         La herramienta de desarrollo todavía presenta algunos problemas.


En conclusión llegada la necesidad podremos elegir algunas de estas herramientas que se acerque al rendimiento, estética, funcionalidad  de aplicaciones nativas.


lunes, 18 de mayo de 2015

Anatomía de un Proyecto Android

 

Para crear un nuevo proyecto ejecutaremos Android Studio y desde la pantalla de bienvenida pulsaremos la opción “Start a new Android Studio project” para iniciar el asistente de creación de un nuevo proyecto.

image

image

image

image

image

Aquí es donde viene la parte en la que nos asustamos al ver por primera ves el entorno de android studio y donde no sabemos donde estamos parados.

image

En primero instancia podremos observar una barra de menu que cuenta con diferentes opciones que por el momento mencionaremos las mas importantes. Como podrá observar cuenta con las funciones básicas de cualquier editor guardar, copiar, pegar deshacer , buscar.  Nos brindara la posibilidad de ejecutar nuestro proyecto , acceder a las propiedades del entorno.

image

Lo siguiente que podremos identificar es la sección de edición donde podremos editar el código fuente en caso de ser archivos java.

image

pero en caso de ser una pantalla visual o layout tendremos dos modos de visualización, el primero una visualización en modo texto donde podremos editar de manera manual el archivo xml.

 image

El modo diseñador es de donde podremos gestionar el entorno visual desde donde utilizaremos el diseñador.

imageEn una sección izquierda podremos ver los controles o vistas que android studio nos proporciona para agregar a nuestra pantalla.

image

un potente escritorio por el que podremos visualizar la pantalla y los cambios que vayamos realizando.

image

una ventana donde podremos tener una jerarquía de los componente que estamos agregando a nuestra pantalla.

image

una ventana de propiedades desde donde podremos modificar las propiedades visuales de cada uno de los componentes de mi pantalla. Solo necesitamos seleccionar el elemento y tendremos a disposición las propiedades asociadas.

image

claramente esto no tendría sentido si no tuviéramos un explorador de archivos del proyecto sobre el que estamos trabajando. Tiene algunas modos de vistas pero el que utilizaremos nosotros sera la vista Proyecto.

image

finalmente llegamos a la estructura de un proyecto de base de android studio  como la siguiente

image

En los siguientes apartados describiremos los elementos principales de esta estructura.

Lo primero que debemos distinguir son los conceptos de proyecto y módulo. La entidad proyecto es única, y engloba a todos los demás elementos. Dentro de un proyecto podemos incluir varios módulos, que pueden representar aplicaciones distintas, versiones diferentes de una misma aplicación, o distintos componentes de un sistema (aplicación móvil, aplicación servidor, librerías, …).

En la mayoría de los casos, trabajaremos con un proyecto que contendrá un sólo módulo correspondiente a nuestra aplicación principal. Por ejemplo en este caso que estamos creando tenemos el proyecto “AnatomiaProyecto” que contiene al módulo “app” que contendrá todo el software de la aplicación de ejemplo.

A continuación describiremos los contenidos principales de nuestro módulo principal.

Carpeta /app/src/main/java

Esta carpeta contendrá todo el código fuente de la aplicación, clases auxiliares, etc. Inicialmente, Android Studio creará por nosotros el código básico de la pantalla (actividad o activity) principal de la aplicación, que recordemos que en nuestro caso era MainActivity, y siempre bajo la estructura del paquete java definido durante la creación del proyecto.

image

Carpeta /app/src/main/res/

Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes, layouts, cadenas de texto, etc. Los diferentes tipos de recursos se pueden distribuir entre las siguientes subcarpetas:

Carpeta
Descripción

/res/drawable/
Contiene las imágenes [y otros elementos gráficos] usados en por la aplicación. Para poder definir diferentes recursos dependiendo de la resolución y densidad de la pantalla del dispositivo se suele dividir en varias subcarpetas:

  • /drawable (recursos independientes de la densidad)
  • /drawable-ldpi (densidad baja)
  • /drawable-mdpi (densidad media)
  • /drawable-hdpi (densidad alta)
  • /drawable-xhdpi (densidad muy alta)
  • /drawable-xxhdpi (densidad muy muy alta :)

/res/layout/
Contiene los ficheros de definición XML de las diferentes pantallas de la interfaz gráfica. Para definir distintos layouts dependiendo de la orientación del dispositivo se puede dividir también en subcarpetas:

  • /layout (vertical)
  • /layout-land  (horizontal)

/res/anim/
/res/animator/
Contienen la definición de las animaciones utilizadas por la aplicación.

/res/color/
Contiene ficheros XML de definición de colores según estado.

/res/menu/
Contiene la definición XML de los menús de la aplicación.

/res/xml/
Contiene otros ficheros XML de datos utilizados por la aplicación.

/res/raw/
Contiene recursos adicionales, normalmente en formato distinto a XML, que no se incluyan en el resto de carpetas de recursos.

/res/values/
Contiene otros ficheros XML de recursos de la aplicación, como por ejemplo cadenas de texto (strings.xml), estilos (styles.xml), colores (colors.xml), arrays de valores (arrays.xml), tamaños (dimens.xml), etc.

No todas estas carpetas tienen por qué aparecer en cada proyecto Android, tan sólo las que se necesiten.

image

Fichero /app/src/main/AndroidManifest.xml

Contiene la definición en XML de muchos de los aspectos principales de la aplicación, como por ejemplo su identificación (nombre, icono, …), sus componentes (pantallas, servicios, …),  o los permisos necesarios para su ejecución. Veremos más adelante más detalles de este fichero.

image

Fichero /app/build.gradle

Contiene información necesaria para la compilación del proyecto, por ejemplo la versión del SDK de Android utilizada para compilar, la mínima versión de Android que soportará la aplicación, referencias a las librerías externas utilizadas, etc. Más adelante veremos también más detalles de este fichero.

En un proyecto pueden existir varios ficheros build.gradle, para definir determinados parámetros a distintos niveles. Por ejemplo, en nuestro proyecto podemos ver que existe un fichero build.gradle a nivel de proyecto, y otro a nivel de módulo dentro de la carpeta /app. El primero de ellos definirá parámetros globales a todos los módulos del proyecto, y el segundo sólo tendrá efecto para el módulo correspondiente.

image

Carpeta /app/libs

Puede contener las librerías java externas (ficheros .jar) que utilice nuestra aplicación. Normalmente haremos referencia a dichas librería en el fichero build.gradle descrito en el punto anterior, de forma que entren en el proceso de compilación de nuestra aplicación. Veremos algún ejemplo más adelante.

Carpeta /app/build/

Contiene una serie de elementos de código generados automáticamente al compilar el proyecto. Cada vez que compilamos nuestro proyecto, la maquinaria de compilación de Android genera por nosotros una serie de ficheros fuente java dirigidos, entre otras muchas cosas, al control de los recursos de la aplicación.Importante: dado que estos ficheros se generan automáticamente tras cada compilación del proyecto es importante que no se modifiquen manualmente bajo ninguna circunstancia.

A destacar la famosa clase “R.java”, donde se define la clase R. Esta clase R contendrá en todo momento una serie de constantes con los identificadores (ID) de todos los recursos de la aplicación incluidos en la carpeta /app/src/main/res/, de forma que podamos acceder fácilmente a estos recursos desde nuestro código a través de dicho dato. Así, por ejemplo, la constante R.layout.activity_main contendrá el ID del layout “activity_main.xml” contenido en la carpeta /app/src/main/res/layout/.

image

Entorno de desarrollo Android (Android Studio)

 

Para empezar  vamos a describir los pasos básicos para disponer en nuestro PC del entorno y las herramientas necesarias para comenzar a programar aplicaciones para la plataforma Android.

Paso 1. Descarga e instalación de Java.

Si aún no tienes instalado ninguna versión del JDK (Java Development Kit) puedes descargarla desde la web de Oracle.

Aunque ya está disponible Java 8, para el desarrollo en Android nos seguiremos quedando por ahora con Java 7. En el momento de escribir este manual la reversión más reciente de esta serie es laversión 7 update 71, que deberemos descargar para nuestra versión concreta del sistema operativo. Por ejemplo, para Windows 64 bits descargaremos el ejecutable marcado como “Windows x64” cuyo nombre de fichero es “jdk-7u71-windows-x64.exe“.

descarga-java

La instalación no tiene ninguna dificultad, se trata de un instalador estándar de Windows donde tan sólo hay que aceptar, pantalla por pantalla, las opciones que ofrece por defecto.

El siguiente paso es opcional, pero puede evitarnos algún que otro problema en el futuro. Crearemos una nueva variable de entorno llamada JAVA_HOME y cuyo valor sea la ruta donde hemos instalado el JDK, por ejemplo “C:\Program Files\Java\jdk1.7.0_71“. Para añadir una variable de entorno del sistema en Windows podemos acceder al Panel de Control / Sistema y Seguridad / Sistema / Configuración avanzada del sistema / Opciones Avanzadas / Variables de entorno.

variable-entorno

Paso 2. Descarga e instalación de Android Studio y el SDK de Android.

Descargaremos Android Studio accediendo a la web de desarrolladores de Android, y dirigiéndonos a la sección dedicada al SDK de la plataforma. Descargaremos el instalador correspondiente a nuestro sistema operativo pulsando el botón verde “Download Android Studio” y aceptando en la pantalla siguiente los términos de la licencia.

descarga-as

Para instalar la aplicación ejecutamos el instalador descargado (en mi caso el fichero se llama “android-studio-bundle-135.1641136.exe“) y seguimos el asistente aceptando todas las opciones seleccionadas por defecto. Durante el proceso se instalará el SDK de Android, los componentes adicionales para el desarrollo sobre Android 5.0, un dispositivo virtual (o “AVD”, más adelante veremos lo que es esto) preconfigurado para dicha versión de Android, y por supuesto el entorno de desarrollo Android Studio.

instalar-as-2

Como puede verse en la imagen anterior, también se instalará y configurará durante la instalación (si tu PC es compatible) el llamado Intel Hardware Accelerated Execution Manager (o “HAXM”), que nos ayudará a mejorar el rendimiento del emulador de Android, más adelante hablaremos de esto. En un paso posterior del instalador se podrá indicar además la cantidad de memoria que reservaremos para este componente (se puede dejar seleccionada la opción por defecto):

instalar-as-6

Durante la instalación tendremos que indicar también las rutas donde queremos instalar tanto Android Studio como el SDK de Android. Para evitar posibles problemas futuros mi recomendación personal es seleccionar rutas que no contengan espacios en blanco.

instalar-as-5

Una vez finalizada la instalación se iniciará automáticamente Android Studio. Es posible que nos aparezca en este momento un cuadro de diálogo consultando si queremos reutilizar la configuración de alguna versión anterior del entorno. Para realizar una instalación limpia seleccionaremos la opción “I do not have a previous version…“.

inicio-as-2

Durante la primera ejecución aparecerá además el asistente de inicio que se encarga de descargar e instalar/actualizar algunos componentes importantes del SDK de Android (si existieran).

inicio-as-3

Paso 3. Actualización de Android Studio.

Este paso también es opcional, aunque recomendable. Tras finalizar el asistente de inicio nos aparecerá la pantalla de bienvenida de Android Studio:

inicio-as-5

Podemos comprobar si existe alguna actualización de Android Studio pulsando el enlace situado en la parte inferior de la pantalla de bienvenida (Check for updates now), lo que nos mostrará información sobre la última actualización disponible (si existe) y nos permitirá instalarla pulsando el botón “Update and restart“. En mi caso, estaba disponible como actualización la versión 1.0.2:

inicio-as-6

Tras la actualización, Android Studio se reiniciará y volveremos a aparecer en la pantalla de bienvenida.

Paso 4. Configuración inicial de Android Studio.

Lo siguiente que haremos antes de empezar a utilizar el IDE será asegurarnos de que están correctamente configuradas las rutas a los SDK de Java y Android.

Para ello pulsaremos la opción “Configure” de la pantalla de bienvenida, tras ésta accederemos a “Project Defaults” y después a “Project Structure”. En la ventana de opciones que aparece revisaremos el apartado “SDK Location” asegurándonos de que tenemos correctamente configuradas las rutas al JDK y al SDK de Android. A continuación muestro la configuración en mi caso, aunque puede variar según las rutas que hayáis utilizado para instalar los distintos componentes.

configurar-as-1

Tras la revisión pulsamos el botón OK para aceptar la configuración y volvemos al menú de la pantalla de bienvenida de Android Studio.

Paso 5. Instalar/actualizar componentes del SDK de Android.

El siguiente paso será actualizar algunos componentes del SDK de Android e instalar otros adicionales que nos pueden ser necesarios/útiles para el desarrollo de nuestras aplicaciones.

Para ello accederemos al menú “Configure / SDK Manager” de la pantalla de bienvenida, lo que nos permitirá acceder al SDK Manager de Android. Con esta herramienta podremos instalar, desinstalar, o actualizar todos los componentes disponibles como parte del SDK de Android.

sdk-manager-1

Los componentes principales que, como mínimo, deberemos instalar/actualizar serán los siguientes:

  1. Android SDK Tools
  2. Android SDK Platform-tools
  3. Android SDK Build-tools (por ahora la versión más reciente)
  4. Una o más versiones de la plataforma Android
  5. Android Support Repository (extras)
  6. Google Play Services (extras)
  7. Google Repository (extras)

El punto 4 es uno de los más importantes, ya que contiene los componentes y librerías necesarias para desarrollar sobre cada una de las versiones concretas de Android. Así, si queremos probar nuestras aplicaciones por ejemplo sobre Android 2.2 y 4.4 tendremos que descargar sus dos plataformas correspondientes. Mi consejo personal es siempre instalar al menos 2 plataformas: la correspondiente a la última versión disponible de Android, y la correspondiente a la mínima versión de Android que queremos que soporte nuestra aplicación, esto nos permitirá probar nuestras aplicaciones sobre ambas versiones para asegurarnos de que funciona correctamente. En este curso nos centraremos en las versiones 4.x y 5.x de Android. Intentaré que todo lo expuesto sea compatible al menos desde la versión 4.0.3 (API 15) en adelante, por lo que en nuestro caso instalaremos, además de la reciente versión 5.0 (API 21), alguna plataforma de la versión 4, por ejemplo la 4.4.2 (API 19).

A modo de referencia, en mi caso seleccionaré los siguientes componentes/versiones (algunos pueden estar ya instalados):

  1. Android SDK Tools (Rev. 24.0.2)
  2. Android SDK Platform-tools (Rev. 21)
  3. Android SDK Build-tools (Rev. 21.1.2)
  4. Android 5.0.1 (API 21)
    1. SDK Platform
    2. Google APIs
    3. Google APIs Intel x86 Atom System Image
  5. Android 4.4.2 (API 19)
    1. SDK Platform
    2. Google APIs (x86 System Image)
  6. Extras
    1. Android Support Repository (Rev. 11)
    2. Google Play Services (Rev. 22)
    3. Google Repository (Rev. 15)

Si nuestro PC no fuera compatible con HAXM, podemos sustituir los componentes 4.3 y 5.2 por los dos siguientes (la funcionalidad será la misma aunque el rendimiento será más lento):

  • 4.3. Google APIs ARM EABI v7a System Image
  • 5.2. Google APIs (ARM Systema Image)

Seleccionaremos los componentes que queremos instalar o actualizar, pulsaremos el botón “Install packages…”, aceptaremos las licencias correspondientes, y esperaremos a que finalice la descarga e instalación. Una vez finalizado el proceso es recomendable cerrar el SDK Manager y reiniciar Android Studio.

Con este paso ya tendríamos preparadas todas las herramientas necesarias para comenzar a desarrollar aplicaciones Android. En próximos apartados veremos como crear un nuevo proyecto, la estructura y componentes de un proyecto Android, y crearemos y probaremos sobre el emulador una aplicación sencilla para poner en práctica todos los conceptos aprendidos.

CÓMO CREAR UN EMULADOR DE ANDROID CON ANDROID STUDIO

 

Una de las funciones que nos ofrece Android Studio es la posibilidad de montar una máquina virtual de Android con la que poder hacer uso del sistema operativo de Google y de sus aplicaciones desde nuestro ordenador. Para poder montar esta máquina virtual lo primero que debemos hacer es haber instalado la herramienta de desarrollo y los SDK necesarios.

image

image

Aquí debemos rellenar los siguientes elementos:

Application Name: Aquí escribiremos el nombre del proyecto, por ejemplo, Emulador Android. Es sólo con fines de identificación.

Company Name: Podemos dejar lo que nos viene por defecto, ya que este aspecto es necesario para subir las aplicaciones a la Google Play, y en un principio no vamos a hacerlo.

Project Location: Localización donde guardaremos nuestro proyecto.

Seguimos con el asistente y llegaremos a una nueva ventana donde debemos seleccionar la versión de Android para la que vamos a desarrollar o, en nuestro caso, la que queremos emular.

 

image

Seguimos con el asistente, dejando las opciones que nos vienen por defecto (ya que están orientadas principalmente a desarrolladores) hasta finalizar con el asistente.

image

image

Una vez pulsemos sobre el botón “Finish” se nos abrirá finalmente el editor de código de Android Studio. Este editor puede ser muy completo y complicado para usuarios sin demasiada experiencia, por lo que vamos a ir directamente a las opciones desde las que configurar y ejecutar el emulador de Android para Windows.

Para ello debemos pulsar sobre el botón “ADV Manager” como veremos en la imagen siguiente o seleccionar esta opción desde el apartado:

  • Tools > Android > ADV manager

image

image

Por defecto tendremos una máquina virtual creada, según la API de desarrollo que hayamos elegido en el asistente inicial. Podemos crear una nueva máquina virtual personalizada pulsando sobre el botón “Create Virtual Device”.

image

Desde aquí podemos elegir el tipo de dispositivo que queremos emular, por ejemplo, un smartphone, una tablet, un smartwatch, etc. Disponemos de varios modelos propios de Google, los “Nexus”, y podemos elegir también modelos genéricos con configuraciones personalizadas. En la parte derecha veremos un resumen de las características de nuestro dispositivo seleccionado.

Seguimos con el asistente y elegiremos el sistema operativo que instalaremos a nuestro emulador. Podemos elegir cualquier versión de Android, siempre y cuando tengamos los correspondientes SDK instalados.

image

Seguimos con el asistente y veremos ya un resumen de las características de nuestro emulador de Android.

 

image

domingo, 30 de noviembre de 2014

Proyecto fin de curso Encuesta Android


Bueno para mis alumnos como saben nos encontramos en la etapa final de nuestro curso de android, motivo por el cual les colaboro con la clase helper del proyecto para acelerar los tiempos.
Recordar que nuestro modelo de SQL server del lado servicio es
image
Este es el código de nuestra clase helper del proyecto que tiene comentado el script de generación de la base de datos sqlite por si quieren correrlo en alguna herramienta local en sus maquinas.
Los servicios de la aplicación estarán publicados de manera indeterminada en mi sitio por lo que podrán practicar con los mismos de manera indeterminada.
package curso.edu.encuestadroid.helper.dao;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;

/*
         
          CREATE TABLE Encuestas (
          Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
          IdEncuesta INTEGER NOT NULL,
          Numero TEXT NOT NULL,
          Estado BOOL NOT NULL DEFAULT True
          );         
         
          CREATE TABLE Preguntas (
          Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
          IdPregunta INTEGER NOT NULL,
          IdEncuesta INTEGER NOT NULL,
          Detalle TEXT,
          FOREIGN KEY(IdEncuesta) REFERENCES Encuestas(IdEncuesta) 
          );
         
          CREATE TABLE Respuestas (
          Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
          IdRespuesta INTEGER NOT NULL,
          IdEncuesta INTEGER NOT NULL,
          IdPregunta INTEGER NOT NULL,
          Detalle TEXT,
          FOREIGN KEY(IdEncuesta) REFERENCES Encuestas(IdEncuesta),
          FOREIGN KEY(IdPregunta) REFERENCES Preguntas(IdPregunta)
          );
          CREATE TABLE Fichas (
          IdFicha INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
          Numero TEXT NOT NULL,
          Fecha DATETIME NOT NULL,
          IdEncuesta INTEGER NOT NULL,
          IdEncuestado INTEGER NOT NULL,
          FOREIGN KEY(IdEncuesta)  REFERENCES Encuestas(IdEncuesta),
          FOREIGN KEY(IdEncuestado) REFERENCES Encuestados(IdEncuestado) 
          );
          CREATE TABLE FichaDetalle (
          IdFichaDetalle INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
          IdFicha INTEGER NOT NULL,
          IdEncuesta INTEGER NOT NULL,
          IdPregunta INTEGER NOT NULL,
          IdRespuesta INTEGER NOT NULL,
          FOREIGN KEY(IdFicha) REFERENCES Fichas(IdFicha),
          FOREIGN KEY(IdEncuesta) REFERENCES Encuestas(IdEncuesta),
          FOREIGN KEY(IdPregunta) REFERENCES Preguntas(IdPregunta),
          FOREIGN KEY(IdRespuesta) REFERENCES Respuestas(IdRespuesta));

*/

public class DatabaseHelper extends SQLiteOpenHelper {
    // Logcat tag
    private static final String LOG = "encuestaandroid";

    // Database Version
    private static final int DATABASE_VERSION = 1;

    // Database Name
    private static final String DATABASE_NAME = "encuestaAndroid";

    // Table Names
    private static final String TABLE_ENCUESTAS = "encuestas";
    private static final String TABLE_PREGUNTAS = "preguntas";
    private static final String TABLE_RESPUESTAS = "respuestas";
    private static final String TABLE_FICHAS = "fichas";
    private static final String TABLE_FICHADETALLE = "fichadetalle";
   
    private static final String CREATE_TABLE_ENCUESTAS = "CREATE TABLE Encuestas ("
                                                          + "Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
                                                          + "IdEncuesta INTEGER NOT NULL,"
                                                          + "Numero TEXT NOT NULL,"
                                                          + "Estado BOOL NOT NULL DEFAULT True"
                                                          + ")";
    private static final String CREATE_TABLE_PREGUNTAS ="CREATE TABLE Preguntas ("
                                                          + "Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
                                                          + "IdPregunta INTEGER NOT NULL,"
                                                          + "IdEncuesta INTEGER NOT NULL,"
                                                          + "Detalle TEXT,"
                                                          + "FOREIGN KEY(IdEncuesta) REFERENCES Encuestas(IdEncuesta)" 
                                                          + ")";
    private static final String CREATE_TABLE_RESPUESTAS = "CREATE TABLE Respuestas ("
                                                          + "Id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
                                                          + "IdRespuesta INTEGER NOT NULL,"
                                                          + "IdEncuesta INTEGER NOT NULL,"
                                                          + "IdPregunta INTEGER NOT NULL,"
                                                          + "Detalle TEXT,"
                                                          + "FOREIGN KEY(IdEncuesta) REFERENCES Encuestas(IdEncuesta),"
                                                          + "FOREIGN KEY(IdPregunta) REFERENCES Preguntas(IdPregunta)"
                                                          + ")";
    private static final String CREATE_TABLE_FICHAS = "CREATE TABLE Fichas ("
                                                          + "IdFicha INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
                                                          + "Numero TEXT NOT NULL,"
                                                          + "Fecha DATETIME NOT NULL,"
                                                          + "IdEncuesta INTEGER NOT NULL,"
                                                          + "IdEncuestado INTEGER NOT NULL,"
                                                          + "FOREIGN KEY(IdEncuesta)  REFERENCES Encuestas(IdEncuesta),"
                                                          + "FOREIGN KEY(IdEncuestado) REFERENCES Encuestados(IdEncuestado)" 
                                                          + ")";
   
    private static final String CREATE_TABLE_FICHADETALLE = "CREATE TABLE FichaDetalle ("
                                                          + "IdFichaDetalle INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
                                                          + "IdFicha INTEGER NOT NULL,"
                                                          + "IdEncuesta INTEGER NOT NULL,"
                                                          + "IdPregunta INTEGER NOT NULL,"
                                                          + "IdRespuesta INTEGER NOT NULL,"
                                                          + "FOREIGN KEY(IdFicha) REFERENCES Fichas(IdFicha),"
                                                          + "FOREIGN KEY(IdEncuesta) REFERENCES Encuestas(IdEncuesta),"
                                                          + "FOREIGN KEY(IdPregunta) REFERENCES Preguntas(IdPregunta),"
                                                          + "FOREIGN KEY(IdRespuesta) REFERENCES Respuestas(IdRespuesta))";
   
    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_TABLE_ENCUESTAS);
        db.execSQL(CREATE_TABLE_PREGUNTAS);
        db.execSQL(CREATE_TABLE_RESPUESTAS);
        db.execSQL(CREATE_TABLE_FICHAS);
        db.execSQL(CREATE_TABLE_FICHADETALLE);
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
       
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_ENCUESTAS);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_PREGUNTAS);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_RESPUESTAS);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_FICHAS);
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_FICHADETALLE);
      
        onCreate(db);
    }
}