Android Development Journal II

Español

After a long time I’m back with Android.

I’ve been reading a bit more of the Android tutorials, and here are the remarks so far:

  • Application life-cycle:
Android application life-cycle
Android application life-cycle
  • Multiple language support:
    • The way that multiple languages is supported is based on the files string.xml that defines the literals that you need to show on your code (meaning that “Don’t use hardcoded messages!”) is a resource file.
    • The key is that you can define that resource as res/values/strings.xml and for each language that you want to support define a new strings as res/values-<language_code>/strings.xml.
    • Those codes are the ISO country standard codes. For example, if you want a spanish string, you should use res/values-es/strings.xml and that’s it. Android takes care to load the corresponding one based on the language of the device.
  • Multiple size/density of screens support:
    1. Layouts:
      • For projects targeting Android prior to 3.2 release, you can take as base the use of 4 generalized sizes for layouts: small, normal, large & xlarge. Combining that with portrait & landscape gives you 16 layouts (usually you don’t need to define all of them, Android tries to adapt the ones you have). The default ones are:
        • res/layout/main.xml; # default (portrait)
        • res/layout-land/main.xml # landscape
      • But if your application wants to have a special large layout, you should define:
        • res/layout-large/main.xml # large (portrait)
        • res/layout-large-land/main.xml # large landscape
      • On new versions, there is a new way of designing layouts, as in here or here (using fragments to create dynamic UI)
    2. Resource generalized densities (i.e. for images)
      • Here you should see the details on the tutorial, but the main idea is similar to the generalized sizes of layouts, for images you have res/drawable-<density>/resource.png where density can be ldpi (0.75 of the baseline), mdpi (baseline, being the 1.0 relative size), hdpi (1.5 baseline) or xhdpi (2.0 baseline). More details here.
    3. Multiple platform support, is accomplished through:

Well, as always I encourage everybody to read the sources, they’re far more better than this, I think this doesn’t even count as a resume. Also since the first post the documentation has grow a lot with new guides (also new API, new downloads with the SDK, etc.. etc..), tips and other lectures. So take a look at it!

I’m not very interested on the rest of those guides, my plan now is to try to port a project I’ve created for my Advanced Computer Graphics course on the University onto Android. It was done on C++ + SDL + OpenGL (I think it was 4.2 but not core, close to ES 1.1) for linux. The main idea would be:

  • Create a thin layer on java to handle any UI interaction (I don’t mind using java in that particular case) learning a bit of Android UI + their approach to java.
  • Port the codebase (should be relatively easy) that way taking some learning on the NDK.
  • Change SDL interaction to touch interface interaction (using the thin layer).
  • Change the OpenGL calls from what it was, to ES 1.1
  • On a second stage, change all OpenGL management to ES 2.0 (learning shaders along the way!)

I’ll see where does this takes me!
Back to Top



Después de un largo tiempo, vuelvo con Android.

Estuve leyendo más de los tutoriales, y hasta ahora lo más destacable que encontré:

  • Ciclo de vida de una aplicación
Ciclo de vida de una aplicación Android
Ciclo de vida de una aplicación Android
  • Soporte multi-lenguaje:
    • La manera en que múltiples lenguajes son soportados es a través del archivo/recurso strings.xml donde se definen los literales que se necesitarán mostrar luego (lo que implica “no uses mensajes hardcodeados!”)
    • La clave está en poder definir este recurso como res/values/strings.xml y luego para cada lenguaje que se desea definir un nuevo strings como res/values-<código_de_idioma>/strings.xml.
    • Estos códigos se refieren a los definidos como estándares ISO para cada país. Por ejemplo, si quisieras agregar soporte en francés deberías crear el archivo res/values-fr/strings.xml y listo. Android se encarga de cargar el recurso correspondiente de acuerdo al lenguaje definido en el dispositivo.
  • Soporte para múltiples tamaños/densidades de pantalla:
    1. Layouts:
      • Para proyectos cuyo objetivo sean versiones de Android anteriores a la 3.2, pueden utilizar como base los 4 tamaños generalizados para layouts small, normal, large & xlarge. Que combinado con las orientaciones portrait & landscape generan 16 diferentes layouts a utilizar (usualmente no es necesario definirlos todos, Adroid trata de adaptar los que ya están definidos). Los layouts por defecto son:
        • res/layout/main.xml; # default (portrait)
        • res/layout-land/main.xml # landscape
      • Pero si, por ejemplo, tu aplicación tuviese un formato diferente en pantallas catalogadas como large, deberías definir:
        • res/layout-large/main.xml # large (portrait)
        • res/layout-large-land/main.xml # large landscape
      • En versiones nuevas, hay nuevas formas de realizar layouts de acuerdo a lo que dice aquí o aquí (utilizando fragmentos para crear IU dinámicas)
    2. Densidades generalizadas para recursos (p.e. imágenes)
      • Hay una mejor explicación en el tutorial, pero la idea es similar a los tamaños generalizados para layouts. Se deben definir los recursos de este tipo como (p.e.) res/drawable-<densidad>/recurso.png donde densidad puede ser ldpi (0.75 de la línea base), mdpi (línea base, siendo el 1.0 en densidad relativa), hdpi (1.5 línea base) or xhdpi (2.0 línea base). Mís detalles acá.
    3. El soporte para múltiples plataformas se logra con:

Como siempre, fomento a todos a que lean las fuentes. Son mucho mejores que esto, creo que esto ni siquiera contaría como resúmen. Además desde el último post la documentación creció muchísimo con nuevas guías (nueva API, nuevas descargas, nueva SDK, etc.. etc..) tips y lecutras. Así que revísenlas!

En mi caso, no estoy muy interesado en el resto de estas guías, mi plan actual es tratar de portar un proyecto que realicé para el curso de Computación Gráfica Avanzada en la Universidad a Android. Fue realizado en C++ + SDL + OpenGL (creo que era 4.2 pero no core, cercano a ES 1.1) para linux. La idea general sería:

  • Crear una capa fina de código java para administrar la interación con la IU (no me molesta utilizar java para ello), aprendiendo un poco de IU en Android y la forma de utilizar java en Android.
  • Portar el fuente aprendiendo a utilizar la NDK.
  • Sustituir SDL por interacciones a través de la interfaz táctil usando lo realizado en java.
  • Cambiar las llamadas viejas a OpenGL ES 1.1 (no debería ser demasiado)
  • En una segunda instancia, pasar de ese OpenGL a OpenGL ES 2.0 (aprendiendo shaders ya de paso!)

Veré a dónde me lleva todo esto!

Advertisements

Leave a Reply (Deja una respuesta)

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s