miércoles, 22 de mayo de 2013

Como crear una pantalla de preferencias (PrefenrenceActivity)

Es bastante común tener que crear en nuestra aplicación una pantalla de preferencias para que el usuario pueda configurar ciertos parámetros de la aplicación. Lo primero que se nos puede venir a la mente es crear un layout desde cero para poder cargar y guardar las configuraciones que deseemos, pero Google ha ideado un sistema bastante sencillo con el que poder crear una pantalla de configuración básica en pocos minutos.

Si nos fijamos en una pantalla cualquiera de configuración de Android nos puede venir a la mente algo parecido a lo siguiente:



En estas pantallas normalmente suelen aparecer checkbox, listas de selección, un texto editable...crear una pantalla de este tipo es bastante sencillo.

Una pantalla de preferencias está compuesta principalmente de dos componentes:
  • xml que contendrá la definición de la pantalla de configuración 
  • Actividad que herede de PreferenceActivity
En primer lugar vamos a crear un nuevo xml llamado preferencias.xml y lo situaremos dentro de /res/xml

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
    android:key="preferencias_principal" >
   <PreferenceCategory android:title="Categoría 1">
     <CheckBoxPreference
          android:key="activo"
          android:summary="Subtitulo de la propiedad"
          android:title="Título de la propiedad" />
   </PreferenceCategory>
    <ListPreference
        android:defaultValue="1"
        android:entries="@arrays/descripciones"
        android:entryValues="@arrays/valores"
        android:key="lista"
        android:summary="Título de la propiedad"
        android:title="Subtitulo de la propiedad" />
 
    <EditTextPreference
        android:defaultValue="texto por defecto"
        android:key="texto"
        android:summary="Título de la propiedad"
        android:title="Subtitulo de la propiedad" />
</PreferenceScreen>

Vamos a analizar el xml para explicar los distintos tipos de propiedades que hemos añadido.

A nivel de estructura general podemos ver que todas las etiquetas deben estar dentro de una etiqueta <PreferenceScreen>

La siguiente etiqueta que nos encontramos es <PreferenceCategory> la cual nos permitirá agrupar una o varias propiedades poniendo un título a esta. En la imagen de ejemplo del principio del post podemos ver una (Personalización)

Vamos ya con las etiquetas de propiedades, la primera de ellas es <CheckBoxPreference> la cual nos mostrará un CheckBox el cual podremos marcar o desmarcar. Esta etiqueta tiene varios atributos que son comunes para todas las etiquetas, como son key (clave con la que se guardará el valor), title (texto principal de la propiedad) y summary (texto secundario, aparece debajo del título y con menor tamaño)

La segunda de las etiquetas que vamos a analizar es <ListPreference>. Esta etiqueta nos mostrará al pulsarla una lista de elementos para que podamos seleccionar uno de ellos.
Aparte de los atributos comunes antes explicados esta etiqueta añade dos propiedades muy importantes, que son "entries" y "entryValues". En la primera deberemos indicar un array con la lista de los literales de los elementos que componen el listado, mientras que en el segundo, debemos añadir la lista de valores asociados a estos.

El array debemos crearlo en un fichero xml que podemos situarlo en /res/values/arrays.xml
Dicho xml podría ser algo así:

<resources>
    <string-array name="descripciones">
      <item>Elemento A</item>
      <item>Elemento B</item>
      <item>Elemento C</item>
    </string-array>
    <string-array name="valores">
      <item>0</item>
      <item>1</item>
      <item>2</item>
    </string-array>
</resources>

Lo último que deberemos hacer es crear una actividad que controle la pantalla de preferencias. Esta actividad deberá extender de PreferenceActivity y añadir el xml que contiene la definición de la pantalla de propiedades.

public class Preferencias extends PreferenceActivity {

    protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         addPreferencesFromResource(R.xml.preferencias);
    }
}

Ya solo quedaría dar de alta la actividad como normalmente hacemos en el fichero AndroidManifest.xml.

Espero que os haya servido de ayuda.

sábado, 18 de mayo de 2013

Como enviar parámetros de una Actividad a otra

Hace unos días veíamos como invocar a una actividad desde otra, en este tutorial vamos a ver como pasar parámetros desde la actividad origen a la destino, para por ejemplo indicar el identificador de una lista para enviárselo a una pantalla de detalle.

Por un lado cuando se invoque a la nueva actividad deberemos realizarlo de la siguiente manera:

       Intent intent = new Intent(this, MI_CLASE.class);
       intent.putExtra("nombre", "Droide Code");
       intent.putExtra("id", 10);
       intent.putExtra("activo", true); 

Como podemos ver lo único que tenemos que hacer es usar el método putExtra del intent para añadir la información que deseemos. El método está sobrecargado para poder añadir todo tipo de información (String, byte, int, long, boolean, etc)

En la Actividad destino podremos recuperar la información de la siguiente manera:

       Bundle extras = getIntent().getExtras();
       String s = extras.getString("nombre");
       int i = extras.getInt("id");
       boolean b = extras.getBoolean("activo");

Simplemente deberemos acceder al Intent con el método getIntent() y posteriormente al objeto Bundle que contiene los extras.


Devolver datos a la actividad origen

Otra posibilidad es devolver información desde la segunda actividad a la de origen cuando esta termine.

Para ello la invocación desde la actividad original deberemos hacerlo de la siguiente manera:

       startActivityForResult(intent, 1);
El segundo parámetro es opcional, e indica el requestCode o código de petición. Podremos enviar un código u otro para que la actividad destino se comporte de una manera determinada.

En la actividad origen tambien deberemos sobreescribir el método onActivityResult:


       @Override  
       protected void onActivityResult(int requestCode, int resultCode, Intent data){
             if (requestCode==1 && resultCode==RESULT_OK) {
                    //código a ejecutar...
             }
       }

Este método se ejecutará cuando la actividad destino finalice y recibirá el requestCode con el que se llamó y el resultado. De esta forma podremos realizar una u otra acción dependiendo del resultado obtenido.

Por último debemos incluir el siguiente código en la actividad destino para devolver el resultado que deseemos y finalizar la actividad:

       Intent intent = new Intent();
       setResult(RESULT_OK, intent);
       finish();

Deberemos instanciar un nuevo Intent y enviarlo junto con el resultado usando el método setResult(). Por último finalizaremos la actividad con finish()

Nota: en la intención que viaja desde la segunda actividad a la primera igualmente puede enviarse la información que deseemos usando el método putExtra.

viernes, 17 de mayo de 2013

Instalación Android Studio


En la anterior entrada de Droide Code hacíamos una breve descripción de Android Studio, el nuevo entorno de desarrollo de Google para Android. En el analizábamos las novedades que anunciaba Google sobre este nuevo IDE.

Hoy mismo lo he instalado no sin algún que otro problema que paso a describir:

  • Descargar el ejecutable del sitio oficial de Android developer. El instalador está disponible para Windows, Linux y Mac
  • Una vez tengamos el instalador y dependiendo de nuestro sistema operativo deberemos instalarlo al igual que cualquier otra aplicación.
  • Una vez instalado tuve un pequeño problema a intentar ejecutarlo, ya que pulsaba sobre el ejecutable y no ocurría nada. Esto se debía a que en el pc en el que instalé la aplicación no tenía configurada la variable de entorno JAVA_HOME y no mostraba ningún mensaje que describiera dicho error.
Para aseguraros de que es esto lo que os está ocurriendo podéis intentar iniciarlo a través del fichero  studio.bat (o studio.sh si estáis en Linux) de la carpeta “bin” que está situada en la ruta de instalación que hayáis seleccionado. Desde este ejecutable si se nos mostrará un mensaje indicando que puede que no tengamos configurado la variable JAVA_HOME.
Para configurar dicha variable deberemos dirigirnos a Panel del control -> Sistema -> Configuración avanzada del sistema. Y en la pestaña opciones avazadas -> variables de entorno. En esta pantalla deberemos añadir una nueva variable cuyo campo clave sea JAVA_HOME y cuyo valor sea la ruta donde tenéis instalado el JDK en mi caso: C:\Program Files\Java\jdk1.7.0_15
Nota: Es importante que sea un jdk y no un jre, y que este sea igual o superior a la 1.5

Una vez tengamos arrancada la aplicación nos aparecerá una pantalla de bienvenida en la que podremos seleccionar entre los proyectos más recientes, crear, importar o abrir nuevos proyectos, así como descargar proyectos de repositorios de Git, Mercurio o SVN. También podremos acceder a la configuración y la documentación de la aplicación.


Espero que os haya servido de ayuda, y estaré encantado de ayudar a todo aquél que lo necesite.



jueves, 16 de mayo de 2013

Google Hangouts. El nuevo servicio de mensajería de Google

Una de las principales novedades de la Google I/O ha sido el anuncio (en parte esperado) de un nuevo servicio de mensajería, que pasará a sustituir a Google Talk.
El nuevo servicio unifica Google Talk con Google+ Messenger proporcionando una nueva interfaz. La nueva aplicación estará disponible para Android, iOS y navegadores como Chrome o Firefox. Con esta nueva estrategia Google pretende competir con sus grandes rivales Whatsapps o Line.

Hasta ahora Google Talk no había terminado de entrar del todo en el mercado (siendo el servicio más antiguo) debido principalmente a la forma relativamente compleja de añadir nuevos amigos: tienes que tener una cuenta gmail, conocer el correo de tus contactos, agregadlo y esperar a que te acepten. Nada que ver con por ejemplo Whatsapps, que simplemente con tener su número en la agenda ya te aparece como contacto.

Las principales novedades serán que permitirá intercambiar imágenes o vídeos y que se podrán realizar videollamadas, pudiendo ser de hasta 10 participantes.







Android Studio, el nuevo entorno de desarrollo (I/O 2013)

Una de las novedades que nos ha dejado la conferencia Google I/0 2013 ha sido la publicación de un nuevo entorno de desarrollo que pasará a sustituir a Eclipse + SDK + ADT. El nuevo entorno pretende simplificar el desarrollo de aplicaciones, estando todo mucho más integrado y pensado para desarrollar específicamente para Android.

Android Studio está basado en  IntelliJ IDEA (El cual para muchos desarrolladores está considerado el mejor IDE del mercado).

  • El principal objetivo es hacerlo todo más usable y orientado a la programación en Android, por lo que para ello se han incluido nuevas refactorizaciones y quick fixes (soluciones rapidas) para corregir errores comunes, así como recomendaciones varias.
  • Se ha incluido un nuevo editor gráfico mucho más potente (basado en drag-and-drop) que mejorará la experiencia y la edición de las pantallas (dicho sea de paso, el que teníamos hasta ahora era bastante mejorable). Este nuevo editor nos dará una vista previa más real del resultado final, pudiendo cambiar entre distintos tipos de tipo de pantalla.
  • Nuevos asistentes para crear pantallas comunes en las que poder basarnos y no tener que realizarlas desde cero
  • Nuevas herramientas para mejorar la usabilidad y la compatibilidad entre distintas versiones


Yo suelo usar Eclipse para desarrollar tanto en Android como en Java en general, pero estoy deseando probarlo a fondo, sobre todo por lo bien que he oido hablar de Intellij IDEA.

Por ahora sigue estando disponible el plugin de Eclipse, pero no han dicho si mantendrán los dos entornos o definitivamente abandonarán el desarrollo del plugin ADT. Supongo que lo mantendrán en la web sin actualizaciones al menos hasta que el nuevo IDE sea un entorno consolidado.

Por otro lado me parece que la Fundación Eclipse no ha jugado sus bazas del todo bien en esta ocasión, ya que podía haberse quedado como la única plataforma de desarrollo para Eclipse y como poco le ha salido un fuerte competidor que además está trabajando codo con codo con Google.

Podemos descargar el instalador desde la página oficial de Android Developer.

En cuanto realice algunas pruebas crearé un nuevo articulo con mis impresiones.



Navegar entre Actividades

En Android tenemos el concepto de Actividad (activity) que es una unidad de interacción con el usuario, es decir lo que podríamos decir que viene a ser una pantalla de una aplicación.

A continuación veremos como navegar entre dos actividades o pantallas.

Lo primero de todo será crear los componentes a los que vamos a navegar:

  • Clase descendiente de Activity
  • Layout que representará la nueva  pantalla
  • Definir en el fichero Manifest de la aplicación la nueva actividad
  • Realizar la invocación a la nueva actividad

Clase descendiente de Activity:

En principio una clase que herede de Activity y sobreescriba el método onCreate() para establecer cual es la vista debería ser suficiente.

public class Activity2 extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);
setContentView(R.layout.layout2);
}
}

Layout:
El xml del layout puede contener cualquier componente que queráis. El nombre del layout para que concuerde con lo configurado en la actividad deberá ser layout2.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentRight="true"
android:layout_alignParentTop="true"
android:layout_marginRight="74dp"
android:layout_marginTop="82dp"
android:text="@string/hello_world"
android:textColor="#00FF00"
android:textSize="23sp" />

</RelativeLayout>

Configurar fichero Manifest:
Deberemos incluir la definición de la siguiente manera dentro del nodo <application>

<activity android:name="Activity2" android:label="Actividad de prueba"/>
Realizar Invocación a la actividad
Desde la actividad origen deberemos ejecutar la nueva actividad de la siguiente forma:


public void lanzarNuevaActividad(View view){
      Intent i = new Intent(this, Activity2.class);
      startActivity(i);
}


Para que este código se ejecute deberemos llamarlo por ejemplo desde el evento onClick de un botón de la actividad origen:

android:onClick="lanzarNuevaActividad"
En la siguiente entrada veremos como pasar parámetros a la actividad destino.



martes, 14 de mayo de 2013

Crear emulador Android en Eclipse

El SDK de Android nos proporciona una herramienta para crear emuladores de terminales para que podamos probar las aplicaciones que realicemos antes de instalarlo en un terminal físico. Para ello utilizaremos el Android Virtual Device Manager que se integra perfectamente en Eclipse con el plugin ADT (intalación entorno desarrollo).

Lo primero que deberemos hacer es ejecutar eclipse y arrancar el Administrador de dispositivos virtuales de Android:



Pulsaremos en New... para crear un nuevo AVD, en la cual podremos configurar los siguientes parámetros:

AVD Name: Nombre que quieras dar al nuevo dispositivo virtual.
Device: Dispositivo a emular. Puede ser uno real, como Nexus 7 o bién uno genérico, donde se indica el tamaño de la pantalla en pulgadas y la resolución del dispositivo. Podrás seleccionar el dispositivo de una lista desplegable. NOTA: Si quieres crear nuevos tipos de dispositivo utiliza la pestaña Device Definition que encontrarás en la lista de dispositivos.
Target:versión SDK que soportará el dispositivo. Solo aparecerán las versiones que hayas instalado desde elAndroid SDK Manager.
CPU/ABI:Tipo de CPU y arquitectura que se va a emular. A tener en cuenta si se va a trabajar en código nativo. La opción más habitual es ARM.
Keyboard: Si se selecciona se supondrá que el dispositivo tiene teclado físico, que será emulado por el teclado del ordenador. En caso contrario se utilizará el teclado en pantalla.
Skin: Si se selecciona se mostrarán a la derecha del dispositivo una serie de botones, entre los que se incluyen: volumen, on/off, teclas de navegación, retorno, casa, menú, etc.
Front/Back Camera:Para activar la emulación de la cámara delantera y trasera.

Memory Options: Memoria que se dedicará al emulador. RAM: memoria total en MB. VM Heap: Memoria dinámica asignada a la máquina virtual en MB.
Internal Storage: Memoria interna del dispositivo. Determinará el número de aplicaciones y datos que podrás instalar. Cuidado, esta memoria se reservará en tu disco duro, por lo que no es conveniente indicar un valor demasiado grande.
SD Card: Memoria externa del dispositivo. Size: tamaño de la memoria. Esta creará un nuevo fichero. File: se utilizará un fichero previamente creado.
Snapshot: Si lo seleccionas podrás congelar la ejecución del dispositivo en un determinado instante. Más tarde, podrás retomar la ejecución en este instante, sin tener que esperar a que se inicialice el dispositivo. Conviene marcarlo para conseguir una carga más rápida.
Use Host GPU: Se habilita la emulación hardware para gráficos OpenGLES. Su navegación entre ventanas será más fluida.

Una vez tengamos creado el AVD podemos seleccionarlo y pulsar sobre "Start". En la ventana que nos aparecerá podremos seleccionar si deseamos reescalar la ventana del emulador al tamaño que queramos. Tambien podremos marcar alguna de las siguientes opciones:

  • Wipe user data. Limpiará los datos del usuario.
  • Launch from snapshot. Lanzará la ejecución desde un punto anteriormente guardado. Esta opción arrancará el emulador en el estado exacto que lo dejamos en la última ejecución.
  • Save to snapshot. Al cerrar el emulador guardará el estado del emulador en ese momento como si de una hibernación se tratase.
Una vez ejecutado podremos usar el emulador como si de un terminal se tratase y ejecutar alguna de las aplicaciones por defecto que vienen instaladas.
Muchas gracias y espero que os haya servido de ayuda.

lunes, 13 de mayo de 2013

Instalación entorno desarrollo (Eclipse + plugin + SDK Android)

En este artículo explicaremos los principales pasos para la instalación del entrono de desarrollo de Android. La propuesta de Google y la que vamos a seguir en el manual es la siguiente:
  • JRE (Java Runtime Environment)
  • Eclipse
  • Android SDK
  • Eclipse Plug-in (Android Development Toolkit - ADT)
Instalación JRE: El jre es la máquina virtual de java y es el software que nos permitirá ejecutar código java en nuestro equipo. La versión mínima requerida es la 5.0, y a no ser que necesitemos una versión especifica para otro software que usemos, recomiendo instalar la última versión disponible, en estos momentos va por la versión 7 (update 21) Podéis descargar el instalador de la siguiente ruta:

Eclipse: Es el IDE recomendado por Google para desarrollar en Android, y puede que el más extendido para el desarrollo de aplicaciones Java.
Podemos descargarlo de la url http://www.eclipse.org/downloads/
En principio cualquier versión que descarguéis debería valer, pero recomiendo la versión Classic por ser menos pesada de ejecutar.

La instalación en si no existe, simplemente se debe descomprimir el fichero que os descarguéis.

Android SDK: El siguiente punto es la instalación del sdk (Software Development Kit) el cual nos permitirá generar aplicaciones Android y su posterior compilación.
También incluye el emulador para poder probar nuestras aplicaciones sin necesidad de instalarlo en un terminal físico.


Podemos descargarlo de la página oficial de desarrollo de Android:


Una vez instalamos deberemos ejecutar el SDK Manager y nos aparecerá una pantalla parecida a la siguiente:



Aquí deberemos seleccionar los componente que deseemos para la versión a la que vayamos a desarrollar y pulsar sobre instalar paquete (paciencia puede tardar un buen rato)


Eclipse Plug-in ADT: Con este plug-in podremos realizar todas las tareas de compilación y ejecución de nuestras aplicaciones desde el mismo eclipse, sin necesidad de ejecutar comandos en la consola en modo texto.

Para ello debemos ejecutar eclipse y dirigirnos a menú Help>Install New Software...
Pulsar sobre el botón Add para añadir un nuevo sitio de descargas e introducir la siguiente url:


Marcaremos la opción Developer Tools y todos sus sub-items


Una vez instalado deberemos reiniciar el Eclipse y dirigirnos a la opción de menú Windows>Preferences… y selecciona Android del panel de la izquierda. Pulsaremos en Browse… para seleccionar la ruta donde hayamos descomprimido el SDK. Aplica los cambios y pulsa OK.

Ya estás listo para empezar a desarrollar en Android!!! Espero que os haya servido de ayuda.

Nota: He instalado tanto en Windows 7 como en Ubuntu, por lo que si tenéis alguna duda en alguno de estos sistemas intentaré resolverlo.
Solo destacar que en Windows 7 tuve que ejecutar el SDK Manager con permisos de administrardor, ya que me dio problemas de permisos.

Porcentaje de uso de versiones de Android (Mayo 2013)

Como todos los meses, Google ha publicado el porcentaje de uso de las distintas versiones de Android. Si estás pensando en desarrollar una aplicación para Android es muy importante tener en cuenta estos datos, para no dejar fuera a un porcentaje demasiado alto de usuarios en el caso de escoger una versión demasiado nueva, o perderte muchas de las nuevas funcionalidades por querer abarcar demasiado mercado.

Version Codename API Distribution
1.6 Donut 4 0.1%
2.1 Eclair 7 1.7%
2.2 Froyo 8 3.7%
2.3 - 2.3.2 Gingerbread 9 0.1%
2.3.3 - 2.3.7 10 38.4%
3.2 Honeycomb 13 0.1%
4.0.3 - 4.0.4 Ice Cream Sandwich 15 27.5%
4.1.x Jelly Bean 16 26.1%
4.2.x 17 2.3%




Como podemos ver, solo el 1,8% tienen versiones anteriores a las 2.2 (API 8), por lo que podría ser buena idea desarrollar nuestras aplicaciones para esas versiones.
Gingerbread sigue siendo la versión más usada con un 38.4%, aunque Ice Cream y Jelly Bean cada vez tienen más terminales, teniendo más de un 53% entre las dos.