La columna 80

El blog técnico-personal de Ángel J. Vico… en español

Instalación de una máquina virtual Android

Posted by Ángel J. Vico en 28 de abril de 2013

Cuando desarrollamos para Android nos vemos en la necesidad de probar nuestras aplicaciones en diversos dispositivos, para garantizar su correcto funcionamiento en configuraciones diferentes. Salvo que dispongamos de muchos y variados dispositivos reales, no nos quedará más remedio que emularlos.

El SDK de Android nos permite crear AVDs (Android Virtual Devices) para diversas versiones del sistema operativo y con variadas características hardware. Pero, seamos realistas, su rendimiento deja bastante que desear, incluso en máquinas potentes.

A medida que van saliendo nuevas versiones de Android el esfuerzo que tiene que realizar el software para emularlas es cada vez mayor, lo que provoca que se ejecuten con bastante lentitud. Y mejor no hablemos de tabletas. Para arrancar un AVD con configuración de tableta hay que armarse de paciencia.

Afortunadamente, tenemos otra opción para emular Android obteniendo un mayor rendimiento: usar una máquina virtual que ejecuta la versión para procesadores Intel x86 de Android. Hay varios proyectos que buscan la mejor forma de realizar esta tarea. Yo me voy a centrar en AndroidVM, que es una de las soluciones más sencillas.

Leer el resto de esta entrada »

Posted in Android, VirtualBox | Etiquetado: , | Leave a Comment »

Diseños Android básicos: TableLayout

Posted by Ángel J. Vico en 5 de noviembre de 2012

Vamos a seguir avanzando en la creación de interfaces de usuario en Android, viendo otro de los diseños básicos que tenemos a nuestra disposición. Hasta ahora hemos visto diseños que permiten colocar vistas unas sobre otra o disponerlas en serie, una a continuación de otra, en horizontal o vertical. Con TableLayout añadimos una nueva dimensión, pudiendo disponer las vistas tanto verticalmente como horizontalmente, en forma de tabla.

Es necesario aclarar que no es el único diseño que permite esta distribución. Recientemente se ha añadido un nuevo diseño, GridLayout, que también permite distribuir las vistas en forma de tabla. Está disponible desde la versión 14 de la API de Android, que se corresponde con la versión 4.0 del sistema operativo (Ice Cream Sandwich), y es bastante más potente que TableLayout.

Por el momento, dado que usar GridLayout impide que la aplicación funcione en versiones anteriores, vamos a centrarnos en ver cómo se utiliza TableLayout y ya hablaremos de GridLayout más adelante.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , | 6 Comments »

Diseños Android básicos: LinearLayout

Posted by Ángel J. Vico en 15 de septiembre de 2012

LinearLayout es otro de los diseños básicos con que contamos en Android para crear las interfaces de usuario de nuestras aplicaciones. A diferencia de FrameLayout, que coloca cada vista que se incluye en él sobre la anterior, LinearLayout coloca las vistas una a continuación de otra, sin superponerlas nunca. Es decir, las alinea.

Esta alineación puede ser vertical u horizontal. O sea, que LinearLayout sirve para colocar vistas en una misma fila o columna, pero no ambas cosas a la vez.

Las vistas se colocan en el mismo orden en se agregan al diseño o en el que aparecen en el archivo XML.

De forma predeterminada, LinearLayout tiende a establecer el mismo tamaño para cada vista que contiene, repartiendo el espacio disponible de forma equitativa entre todas ellas. Sin embargo, algunas propiedades de las vistas y ciertos parámetros que el propio LinearLayout añade permiten variar este comportamiento.

Veamos cómo sacarle partido a este diseño.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , | 1 Comment »

Especializaciones del diseño FrameLayout: ScrollView y HorizontalScrollView

Posted by Ángel J. Vico en 1 de septiembre de 2012

En el post anterior vimos las características del diseño FrameLayout y ejemplos de cómo utilizarlo en nuestras aplicaciones. Es un diseño muy sencillo y muy eficiente, motivo por el cual se usa como base para otras muchas vistas.

En este post me voy a centrar en dos de las más parecidas: ScrollView y HorizontalScrollView. Ambas actúan como contenedores genéricos añadiendo una funcionalidad muy concreta al FrameLayout: desplazamiento.

Veamos cómo funcionan.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , | 1 Comment »

Diseños Android básicos: FrameLayout

Posted by Ángel J. Vico en 22 de agosto de 2012

Llevo ya unos cuantos posts dedicados a la interfaz de usuario en Android. Empecé hablando de las actividades y su ciclo de vida, y continué con varios posts sobre las vistas, la forma en que se organizan en diseños y cómo se muestran esos diseños en las actividades. También hemos visto ya los dos tipos principales de vistas que tenemos, diseños y widgets e incluso he enumerado algunos de los más usuales, incluyendo una breve descripción de su cometido.

Es el momento ahora de profundizar más en esas vistas, viendo más detalles sobre ellas y ejemplos de uso. Empezaremos por los diseños básicos, dado que será lo primero que tengamos que crear en nuestra actividad, para subdividir el espacio y controlar la ubicación de los widgets. En concreto, comenzaremos por el FrameLayout, el diseño más sencillo de todos los disponibles, pero también el más eficiente.

FrameLayout no realiza ninguna distribución de las vistas, simplemente las coloca unas encima de otras. Esto le evita tener que relacionar los tamaños de unas vistas con los de las demás, por lo que se ahorra recorridos del árbol de vistas, tardando menos en mostrar su contenido.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , | Leave a Comment »

Diseñando interfaces en Android: codificación

Posted by Ángel J. Vico en 9 de octubre de 2011

Hagamos un rápido repaso de lo principal que hemos visto hasta ahora sobre creación de interfaces de usuario en Android:

  • Las aplicaciones Android muestran su interfaz por medio de las actividades (post), las cuales tienen un ciclo de vida que es mucho más que simplemente mostrarse ante el usuario y permitirle que interactúe (post 1 y post 2).

  • La interfaz de usuario se crea incluyendo vistas en las actividades. El hecho de que algunas de esas vistas actúen como contenedores de otras vistas permite diseñar interfaces de usuario complejas partiendo de elementos bastante sencillos (post).

  • La mejor forma de diseñar una interfaz de usuario es hacerlo en un archivo XML, accediendo a las propiedades de las vistas por medio de atributos directamente en el código XML (post). Por su parte, las vistas contenedoras proporcionan parámetros de diseño a las vistas que contienen, accesibles también por medio de atributos en el XML (post).

Aunque en todo momento hemos ido relacionando los elementos que se utilizan en XML con clases y métodos Java, lo cierto es que a la hora de proponer ejemplos me he limitado a mostrar código XML. No hemos visto cómo utilizar esos archivos XML en un proyecto ni cómo crear esas mismas interfaces directamente en Java. En este post voy a poner remedio a ambas cosas.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , , , , , , , , , | 1 Comment »

Recursos en Android: dimensiones

Posted by Ángel J. Vico en 3 de octubre de 2011

Las dimensiones son recursos XML que sirven para especificar tamaños de elementos de la interfaz de usuario de más formas que simplemente en píxeles, que sería lo habitual.

Están formadas por un valor numérico con decimales (float) y una cadena de texto de dos caracteres que representa la unidad en la que se expresa el valor numérico. En el archivo XML ambos datos se escriben juntos, en una sola cadena de texto, sin espacio o separadores entre ellos.

La ventaja que representan es que la mayoría de las unidades son relativas, tanto a características físicas del dispositivo en el que se están utilizando, como a diversos elementos de estilo que estén activos en un momento dado. Esto permite que unos mismos valores utilizados en un diseño sean traducidos a tamaños diferentes en cada dispositivo en que se ejecute la aplicación, de forma que la experiencia del usuario sea similar.

Si usáramos siempre medidas expresadas en píxeles podría ocurrir que un elemento que tiene un tamaño adecuado para su uso en un dispositivo en particular se viera demasiado pequeño en otro dispositivo con mayor densidad de píxeles (cantidad de píxeles por cada pulgada de pantalla).

Queda claro que las dimensiones las vamos a utilizar bastante, así que veamos cómo hacerlo.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , , , , , | Leave a Comment »

Diseñando interfaces en Android: padding y margen

Posted by Ángel J. Vico en 25 de septiembre de 2011

Al diseñar una interfaz de usuario, una de las cosas de la que nos damos cuenta en seguida es que las vistas que colocamos tienden a colocarse demasiado cerca unas de otras. Si utilizamos wrap_content para que el tamaño de la vista se ajuste al contenido (algo bastante habitual), nos encontramos con frecuencia con textos excesivamente pegados unos a otros, elementos demasiado cerca de los bordes, etc.

Echamos en falta rápidamente una forma de dejar algo de espacio entre las vistas o de alejar su contenido de los bordes. Y para ello Android nos proporciona dos tipos de propiedades, padding y margen (margin). Las dos tienen una función similar, pero la realizan de diferente forma. La principal diferencia es que el padding forma parte de la vista y el margen del diseño. Este detalle, aparte de influir sobre en qué clase se incluyen las propiedades, determina dónde se sitúa ese espacio adicional que añaden. Mientras que el padding es un espacio situado entre el borde de la vista y su contenido, el margen se sitúa entre el borde de la vista y los bordes de los elementos que la rodean o del diseño que la contiene.

Seguramente quede más claro con la siguiente captura:

Diferencia entre padding y margen

El fondo (background) de todos los TextView de esta interfaz se ha establecido en verde, por lo que cada recuadro verde muestra el área total que está ocupando la vista, sus límites. Se puede observar como, si no utilizamos ni padding ni margen (segunda fila), el tamaño de cada vista se ajusta completamente al contenido y las vistas quedan totalmente pegadas unas a otras. Cuando usamos padding (filas 1 y 3) añadimos un espacio entre el texto y los límites de la vista (espacio que se rellena con el fondo). Por su parte, el margen (filas 1 y 4) agrega ese espacio alrededor de los límites de la vista pero por fuera de ella, provocando que las vistas se separen unas de otras y de los bordes de los LinearLayout que las contienen (y permitiendo que se vea el fondo del diseño, azul o rojo en la interfaz de ejemplo). Finalmente, la captura también demuestra que se pueden utilizar las dos propiedades a la vez (fila 1) y el resultado que proporcionan.

El padding es una propiedad de las vistas, como vimos en un post anterior. El margen, al ser externo a las vistas, se deja en mano de los contenedores de vistas, por lo que se implementa como parámetro de los diseños. Sin embargo ambas se utilizan de forma muy similar. Veamos cómo:

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , , , , , | Leave a Comment »

Diseñando interfaces en Android: parámetros

Posted by Ángel J. Vico en 20 de septiembre de 2011

En el post anterior vimos cómo se crean diseños en XML y cómo los atributos que tenemos disponibles en XML se corresponden, de forma más o menos directa, con métodos de las clases Java que implementan las vistas. También hemos visto algunas de las propiedades más comunes de las vistas, que heredan tanto widgets como diseños.

En este post vamos a profundizar algo más en los diseños viendo, sobre todo, qué cosas tienen en común, antes de entrar en detalles particulares de cada uno de los tipos que tenemos disponibles.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , , , , , | Leave a Comment »

Diseñando interfaces en Android: XML y propiedades

Posted by Ángel J. Vico en 17 de septiembre de 2011

En posts anteriores vimos de qué elementos disponemos en Android para diseñar las interfaces de usuario de nuestras aplicaciones. Por un lado tenemos actividades para crear cada una de las diferentes pantallas, y vistas para crear el contenido de cada actividad. Además, también hemos visto que tenemos dos tipos de vistas: diseños para subdividir la actividad y situar el resto de vistas, y widgets para mostrar información al usuario y permitirle interactuar con la aplicación.

En este post vamos a ver cómo se crean todos estos elementos y qué propiedades tienen en común. Más adelante veremos cómo, una vez creados, los incluimos y mostramos en nuestras actividades.

Podemos crear widgets y diseños tanto por código como utilizando archivos de recursos en XML situados en la carpeta layouts. Ni qué decir tiene que es preferible optar por la segunda opción, que no sólo permite tener una vista previa aproximada de la interfaz en tiempo de codificación, sino también disponer de diferentes interfaces de usuario para una misma actividad. Esto permite escoger la más adecuada en tiempo de ejecución en función del tamaño de la pantalla o del idioma que tenga configurado el dispositivo, por ejemplo.

Aunque me centraré en los recursos XML, también iré mencionando los elementos Java que se corresponden con ellos. En este otro post explico cómo se crean interfaces de usuario completas por código.

Leer el resto de esta entrada »

Posted in Android | Etiquetado: , , , , , | 1 Comment »