Categoría: Android

Android: Elementos básicos (II)

En este segundo post vamos a ver cómo crear imágenes y los elementos de selección checkbox y radio.

IMÁGENES

Android tiene dos elementos para añadir imágenes a nuestra aplicación: ImageView e ImageButton, análogos a TextView y Button respectivamente. La imagen a mostrar se indica en el atributo XML android:src o con el método setImageResource(int).

¿Cómo cargar la imagen res/drawable/myimage.png? (2 ejemplos)

ImageView iv= (ImageView) findViewById(R.id.myimageview);
iv.setImageResource(R.drawable.myimage);
Resources res = getResources();

Drawable drawable = res.getDrawable(R.drawable.myimage);

¿Cómo crear una imagen con XML?

<ImageButton android:id="@+id/myimageview"     
  android:layout_height="wrap_content"     
  android:layout_width="wrap_content"     
  android:src="@drawable/myimage" />

CHECKBOX

El nombre de un checkbox en Android es fácil de recordar, ya que es igual, Checkbox. En Java, podemos registrar un listener OnCheckedChangeListener, que notifique cuando se selecciona o deselecciona el checkbox:

<CheckBox android:id="@+id/my_check"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Unchecked" />
 public class My_Checkbox extends Activity 

         implements CompoundButton.OnCheckedChangeListener {
   CheckBox cb;

   @Override
   public void onCreate(Bundle icicle) {
       super.onCreate(icicle);
       setContentView(R.layout.main);
       cb=(CheckBox)findViewById(R.id.my_check);
       cb.setOnCheckedChangeListener(this);
   }
   public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
       if (isChecked)  cb.setText("Checked");
       else cb.setText("Unchecked");
   }
}

RADIO

Un radio en Android es un RadioButton y un grupo de radios, RadioGroup, donde sólo un radio podrá estar seleccionado.

¿Cómo crear un grupo de radios en XML?

<RadioGroup
      android:layout_width="fill_parent"
      android:layout_height="wrap_content"
      android:orientation="vertical">
      <RadioButton android:id="@+id/radio_red"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="Red" />
      <RadioButton android:id="@+id/radio_blue"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="Blue" />
</RadioGroup>

¿Cómo podemos mostrar un mensaje cuando se selecciona un radio?

Creamos la acción a realizar con View.OnClickListener:

private OnClickListener radio_listener = new OnClickListener() {
   public void onClick(View v) {
     // Perform action on clicks
     RadioButton rb = (RadioButton) v;
     Toast.makeText(My_Class.this, rb.getText(), 
              Toast.LENGTH_SHORT).show();
   }
};

En el método onCreate, asociamos los radios con el listener:

final RadioButton radio_red = (RadioButton) findViewById(R.id.radio_red);
final RadioButton radio_blue = (RadioButton) findViewById(R.id.radio_blue);
radio_red.setOnClickListener(radio_listener);
radio_blue.setOnClickListener(radio_listener);
Referencias:

Android: Elementos básicos

En este post vamos a ver cómo crear etiquetas, campos de texto y botones en Android, tanto en XML como dinámicamente con Java.

ETIQUETAS

Una etiqueta en Android es un TextView. Las etiquetas son textos que no pueden ser modificados directamente por el usuario.

¿Cómo crear una etiqueta con XML?

<TextView android:id="@+id/textview"
  android:layout_width="fill_parent"
  android:layout_height="fill_parent"
  android:text="Hola mundo"/>

 ¿Cómo crear una etiqueta dinamicamente?

public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   TextView tv = new TextView(this);
   tv.setText("Hola mundo");
   setContentView(tv);
}

CAMPOS DE TEXTO

Un campo de texto en Android es un EditText, que es una subclase de TextView.

¿Cómo crear un campo con XML?

<EditText android:id="@+id/entry"
   android:layout_width="fill_parent"
   android:layout_height="wrap_content"
   android:layout_below="@id/label"
   android:singleLine="false"/>
Si el atributo singleLine está a false, el usuario podrá introducir varias líneas en ese campo de texto.

¿Cómo crear un campo dinamicamente?

EditText et = new EditText(this);

BOTONES

Un botón en Android es un Button, que es una subclase de TextView.

¿Cómo crear un botón con XML?

<Button android:id="@+id/my_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/my_button_text"/>

¿Cómo crear un botón dinamicamente?

Button b = new Button(this);
b.setText("My button");
 A partir de la versión 1.6 de Android, podemos definir la acción que va a realizar un botón desde el fichero XML:
<Button android:onClick="miAccion"... />

Así, hacemos que la Activity no tenga que implementar la interface View.OnClickListener. Sólo tiene que definir un método público que devuelva void, con una View como argumento que será la referencia al botón que se ha clickeado.

public void miAccion(View view) {
     // Acciones
}
Referencias:

Android: Crear Layouts XML

Un layout define la arquitectura de la UI de una Activity, donde se definen todos los elementos que aparecerán en ella.

En Android se pueden crear estos elementos dinámicamente o con ficheros XML. Cuando hay elementos que no se conocen en tiempo de compilación, hay que crearlos dinámicamente (View, ViewGroup). Si la aplicación sabe a priori todos los elementos que va a tener, normalmente se utilizan los ficheros XML.

¿Qué características tienen estos ficheros XML?

  • Contienen los elementos y contenedores necesarios para formar una vista.
  • Permiten una mejor separación de la presentación y el código que controla el comportamiento.
  • Se crean en el directorio res/layout.
  • Cada fichero debe contener un solo elemento root, siendo éste un objeto View o ViewGroup:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" 
       android:layout_height="fill_parent" 
       android:orientation="vertical" >
  • Los atributos de los elementos XML describen su apariencia y/o comportamiento.
  • Podemos crear nuestros propios elementos creando subclases de android.view.View.
  • El fichero R.java que se crea en gen/, permite acceder a los elementos de estos ficheros desde código Java.
  • Si queremos que un elemento sea accesible desde Java, tenemos que asignarle un identificador:
      * android:id=»@+id/my_button» : debe crearse el elemento my_button y añadirse a R.java
      * android:id=»@id/my_button» : hace referencia a un elemento ya existente en R.java
      * android:id=»@android:id/empty» : hace referencia al id de un recurso propio de Android.R en vez del fichero local R.java.

¿Qué ocurre cuando compilamos la aplicación?

Cada XML se convierte en una View que debe ser cargada desde el método Activity.onCreate() con setContentView(). Para acceder a sus elementos, utilizamos el método findViewById() y el identificador del elemento (R.id.nombre).

EJEMPLO: Imaginemos que hemos creado un layout llamado res/layout/main.xml, con el siguiente botón:

<Button android:id="@+id/my_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/my_button_text"/>

Al compilar la aplicación, desde Java tendremos acceso a él de la siguiente manera:

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main); // Fichero layout main.xml
    Button btn=(Button) findViewById(R.id.my_button);
}

En siguientes posts aprenderemos más elementos que puede tener un Layout.

Referencia: http://developer.android.com/guide/topics/ui/declaring-layout.html

Android: Activities

Una activity es el componente que se asocia a una pantalla de la aplicación, desde la que el usuario puede interactuar. Una aplicación suele estar compuesta por varias activities, ya que utiliza varias pantallas.

¿Qué características presentan?

  • Se definen en el AndroidManifest.xml con la etiqueta <activity>
  • La Activity que se especifica como principal, es la que se le presenta al usuario cuando inicia la aplicación.
  • Una Activity puede arrancar otra, con startActivity(Intent) o startActivityForResult(Intent,int) (esto se verá más adelante en otro post).
  • Se manejan con una pila de Activities, donde cada una de ellas puede tener el siguiente estado:
          * Active: está en primer plano y es visible para el usuario (está en el top de la pila)
          * Paused: ha perdido el foco pero sigue visible. El sistema podría eliminarla si se necesita urgentemente memoria.
          * Stopped: no es visible para el usuario. El sistema a menudo las eliminarla cuando se necesita memoria.

¿Qué son desde el punto de vista Java?

  • Son clases públicas que heredan de android.app.Activity.
  • El ciclo de vida de una Activity está compuesto por los siguientes métodos:
public class ExampleActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // La actividad está siendo creada
        // Aquí es donde suele llamarse a setContentView(int) 
        //y a findViewById(int).
    }
    @Override
    protected void onStart() {
        super.onStart();
        // Invocado justo antes de hacerse visible
    }
    @Override
    protected void onResume() {
        super.onResume();
        // La actividad se ha vuelto visible (ahora está "Active").
    }
    @Override
    protected void onRestart() {
        super.onStart();
        // La actividad va a iniciarse otra vez, 
        // después de haber sido Stopped.
    }
    @Override
    protected void onPause() {
        super.onPause();
        // La actividad va a pasar al estado Paused
        // Aquí debemos comitear todos los cambios 
        // hechos por el usuario, de datos persistentes,
        // y parar todo lo que consuma CPU
    }
    @Override
    protected void onStop() {
        super.onStop();
        // La actividad no es visible (ahora está "Stopped")
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // La actividad va a ser eliminada
    }
}
  •  Para guardar el estado de una actividad, se utiliza el método onSaveInstanceState(). El sistema normalmente llama a este método antes de que una actividad se vuelva vulnerable a ser eliminada, utilizando un objeto Bundle que almacena la información como pares nombre-valor. Así, si se restaura la actividad, el sistema pasa este Bundle en el método onCreate(), para poder recuperar su estado previo. Si no hubiese información previa, Bundle sería null.

Como no se garantiza que el sistema llame siempre a onSaveInstanceState(), sólo se debe usar para guardar datos no persistentes (para eso ya está onPause()).

RETO: Ahora que ya conocemos los estados de una Activity, los métodos Java de su ciclo de vida y sus transiciones ¿Os atrevéis a dibujarlo?

Referencia: http://developer.android.com/guide/topics/fundamentals/activities.html

Android: Estructura de un proyecto

En un proyecto Android podemos encontrar las siguientes carpetas y ficheros:

  • AndroidManifest.xml: fichero XML que describe la aplicación con sus componentes, permisos, librerías externas que necesita…
  • bin/: contiene el código compilado. Un proyecto Android se compila normalmente en un fichero .apk que se instala en el dispositivo y que encontraremos en este directorio.
  • libs/: contiene JARs externos que necesita la aplicación
  • src/: contiene el código fuente de la aplicación
  • res/: contiene recursos, como layouts, imágenes, …
      • color/: ficheros XML que describen colores
      • drawable/: imágenes
      • layout/: ficheros XML que representan partes de una pantalla
      • menu/: ficheros XML que representan menús
      • raw/: ficheros de propósito general
      • values/: strings, dimensiones, …
      • xml/: ficheros XML de propósito general
  • jni/: contiene el código fuente nativo creado con Android NDK
  • gen/: contiene los ficheros generados por ADT, como por ejemplo, el fichero R.java (la primera vez que compilemos nuestro proyecto, se creará este fichero, que contiene un número de constantes a distintos recursos del directorio res/. No se debe modificar a mano)
  • assets/: contiene otros ficheros estáticos que queremos que se incluyan en el .apk
  • build.properties y build.xml: ficheros que se utilizan si estamos utilizando Ant desde línea de comandos y no Eclipse.
  • default.properties: configuraciones del proyecto. Este fichero debe estar incluido en el sistema de control de versiones que estemos utilizando y no editarlo localmente

Referencia: http://developer.android.com/guide/developing/projects/index.html#ApplicationProjects

Android: Crear AVDs

Android nos proporciona un emulador de dispositivos Android, permitiéndonos desarrollar y testear una aplicación Android cómodamente desde nuestro ordenador. Este emulador puede simular tantos dispositivos como necesitemos, y a cada uno de ellos se les llama Android Virtual Device (AVD).

La primera vez que ejecutemos una aplicación Android desde Eclipse, si todavía no hemos creado ningún AVD, nos dirá que creemos una para poder ejecutar la aplicación. Por eso, vamos a ver cómo crear nuestro primer AVD:

1) Pinchamos en «Window > Android SDK and AVD Manager > New…»

2) Nos aparecerá una ventana donde indicaremos:

  • El nombre del AVD (ej. MyFirstAVD)
  • La versión de Android que se ejecutará en el dispositivo virtual (ej. Android 3.0 – API Level 11)
  • Dónde se van a almacenar los datos de usuario y el tamaño de la SD Card (ej. 32 MiB)
  • La resolución y apariencia del dispositivo (ej. Default (WXGA))
  • Si se va a necesitar hardware, como por ejemplo una cámara o un teclado.

A partir de la versión 3.0 de Android, para mejorar el tiempo de inicio del emulador, se ha añadido la posibilidad de realizar snapshots. De esta manera, cuando cerramos el emulador se guarda un snapshot del estado del AVD y ésta se usa la siguiente vez que se inicia. Esto acelera el inicio pero hace que el cierre del emulador se vuelva más lento, por tener que hacer ese snapshot. Por eso Google recomienda desactivar ‘Save to snapshot’ después de que ya tengamos un snapshot inicial.

3) Terminamos pinchando en ‘Create AVD’

Para testear nuestra aplicación, deberíamos crear varios AVD’s con distintas configuraciones, por ejemplo, con diferentes versiones de Android. Así comprobamos que nuestra aplicación funciona correctamente en cada una de ellas.

Referencia: http://developer.android.com/guide/developing/devices/index.html

Android: Configurando el entorno

Para empezar a programar con Android, primero es necesario configurar el entorno de desarrollo. Para ello, vamos a ver de una manera rápida y esquemática los pasos que hay que seguir:

1) Descargamos el SDK de Android

2) Instalamos el plugin ADT (Android Development Tool) para Eclipse:

  • Pinchamos en «Help > Install New Software… > Add» y añadimos un nuevo site llamado ‘ADT Plugin’ con URL: https://dl-ssl.google.com/android/eclipse/
  • Seleccionamos el checkbox que ha aparecido junto a «Developer Tools» y pinchamos ‘Next’ hasta que tengamos que aceptar los ‘License agreements’. Para terminar, pinchamos en ‘Finish’.
  • Cuando se termine de instalar el plugin, pinchamos ‘Ok’ en el mensaje que nos aparecerá y reiniciamos Eclipse.

3) Pinchamos en ‘»Window > Preferences > Android» y seleccionamos la carpeta donde hemos descargado el SDK.

4) Pinchamos en «Window > Android SDK and AVD Manager > Available packages» e instalamos los paquetes que necesitemos: SDK Platform-tools, SDK Platform, Documentation, Samples, etc…

Si queremos debugear nuestra aplicación, existe la herramienta Dalvik Debug Monitor Server (DDMS). Para utilizarlo en Eclipse, pinchamos en «Window > Open Perspective > Other…» y la seleccionamos.