Hola mundo en Android

Crear el proyecto

Una vez instalado el entorno de desarrollo de Android, vamos a crear un proyecto básico de Hola Mundo con Android. Elegimos "File" -> "New" -> "Other" -> "Android" -> "Android Project"

Vamos rellenando y aceptando ventanas hasta tener nuestro proyecto. Esto nos creará un proyecto básico "Hola Mundo" en Android que podremos arrancar.

Ejecutar el proyecto

Sobre el proyecto sacar el menú con el botón derecho del ratón "run as" -> "Android Application". Tras un rato de espera se arrancará nuestro dispositivo virtual de Android si no estaba ya y aparecerá nuestro "Hola Mundo".

Si en "Run As" no nos aparece "Android Application", en "Run As" seleccionar "Run Configurations". Aparecerá una ventana en la que debemos ver "Android Application". Seleccionarla y pulsar el botón "Launch new configuration", arriba a la izquierda.

El restultado tras una espera, debe ser el de la imagen

Algunos conceptos básicos

Vamos a ver sin mucho detalle algunas de las cosas que ha creado eclipse, para ir entendiendo lo básico de una aplicación Android.

Estructura del proyecto

En el proyecto recién creado tenemos los siguientes directorios

• src Es donde estarán nuestras clases java. Ahí se crea nuestra clase HolaMundo.java (el nombre depende del nombre que le hayamos dado al proyecto) y que hereda de "Activity", una clase de Android de la que deben heredar todas las ventanas Android.
• get Un directorio en el que se generarán automáticamente clases de utilidad en java. No debemos preocuparnos de él, puesto que eclipse lo actualizará automáticamente cuando sea necesario.
• Android 4.0.3 contendrá el jar de android
• Android dependencies con dependencias
• assets Ficheros que queramos que se incluyan en nuestra aplicación. No se generará ningún tipo de índice para ellos, por lo que desde nuestra aplicación Android deberemos acceder a ellos a través de su path.
• bin Aquí se generará todo lo necesario para ejecutar nuestra aplicación y ponerla en nuestro dispositivo.
• res Distintos ficheros de configuración e iconos. Deberemos ir tocándolos en nuestra aplicación según la vayamos definiendo. Se generarán índices para estos recursos en las clases generadas bajo el directorio gen, por lo que podremos acceder a estos ficheros desde nuestra aplicación Android sin necesidad de referenciar su path, bastará con el índice.
• AndroidManifest.xml, proguard-project.txt y project.properties son ficheros con algunos detalles de nuestra aplicación, que también deberemos ir tocando según lo vayamos necesitando.

La ventana de nuestra aplicación

Android llama a cada una de las pantallas o ventanas que mostraremos en nuestra aplicación "Activies". Aunque se pueden construir estas ventanas desde código, lo habitual es hacerlo con un fichero xml. El fichero para nuestra aplicación "Hola Mundo" está en res/layout/main.xml

<?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" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />

</LinearLayout>

En este fichero xml se debe poner un contenedor (LinearLayout en nuestro caso) que tenga dentro componentes (TextView en nuestro caso) y otros contenedores que a su vez pueden tener más contenedores y componentes. Algunos detalles

• LinearLayout poner los componentes que contiene seguidos uno detrás de otro. Como le hemos puesto orientación vertical, lo hará de arriba a abajo. El ancho y alto son obligatorios y con "fill_parent" le estamos indicando que ocupe todo el espacio disponible. Al ser el contenedor principal de nuestra aplicación, ocupará prácticamente toda la pantalla de nuestro dispositivo.
• TextView es una caja de texto. El ancho "fill_parent" indica que ocupe el mismo ancho que su padre, es decir el LinearLayout que a su vez ocupa todo el ancho de la pantalla. El alto "wrap_content" indica que ocupe el alto necesario para mostrar correctamente su contenido, es decir, el alto de una caja de texto con una línea de texto dentro. El texto se podría poner "a pelo" de esta forma android:text="Hola mundo", pero Android aconseja meter los textos en un fichero de recursos y acceder a ellos por su nombre. Y así queda lo que hay en el fichero android:text="@string/hello". Donde @string indica que se está referenciando el fichero de textos y "hello" es el nombre que le hemos dado al texto. Vamos a verlo ahora

Fichero de textos

El fichero con los textos está en res/values/strings.xml y su contenido es el siguiente

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="hello">Hello World, AndroidHolaMundoActivity!</string>
    <string name="app_name">AndroidHolaMundo</string>

</resources>

que no son más que un par de cadenas de texto que aparecerán en nuestra aplicación: el nombre de la aplicación y el contenido de la caja de texto. Podemos poner ahí los textos que queramos dando un nombre a cada uno ("hello" y "app_name" en el ejemplo). Luego, desde el fichero xml de la ventana (main.xml en nuestro caso), podemos acceder a estos recursos con android:text="@string/hello"

Fichero java con la ventana

Cada ventana (Activity) que hagamos, debe tener un fichero java asociado. Esa clase java debe heredar de Activity. En nuestro ejemplo está en src/com/chuidiang/ejemplos/android/AndroidHolaMundoActivity.java y su contenido es

ackage com.chuidiang.ejemplos.android;

import android.app.Activity;
import android.os.Bundle;

public class AndroidHolaMundoActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Debemos sobreescribir el método onCreate() de la clase padre para hacer lo que necesitemos cuando se cree nuestra ventana. La línea super.onCreate(savedInstanceState) sirve para recuperar el estado anterior de nuestra ventana si lo hubiera, no debemos preocuparnos ahora por eso.

La línea importante es setContentView(R.layout.main) donde le estamos diciendo a nuestra clase java qué debe mostrar. Debe mostrar el main.xml con el que definimos la ventana y la forma de referenciar a ese xml es con R.layout.main. Vamos a ver por qué.

Acceso a recursos desde código

Cuando generamos o modificamos ficheros de recursos, eclipse genera automáticamente unas clase java para poder acceder a ellos de forma fácil. Eclipse las mete en el directorio "gen" y en concreto, crea una clase R con enteros para todos los recursos. Su contenido puede ser como este

package com.chuidiang.ejemplos.android;

public final class R {
    public static final class attr {
    }
    public static final class drawable {
        public static final int icon=0x7f020000;
    }
    public static final class id {
        public static final int textview=0x7f050000;
    }
    public static final class layout {
        public static final int main=0x7f030000;
    }
    public static final class string {
        public static final int app_name=0x7f040001;
        public static final int hello=0x7f040000;
    }
}

Vemos ahí identificadores para los iconos, la caja de texto, el layout principal y los textos. Desde nuestro código java podemos pasar esos identificadores a los métodos correspondientes para acceder a ellos. En nuestro ejemplo, setContentView(R.layout.main) hace que el contenido de nuestra ventana principal sea el recurso R.layout.main que corresponde al main.xml

Otros ficheros

Hay además otros ficheros que le dicen a Android cómo manejar nuestra aplicación. En concreto son de interés AndroidManifest.xml cuyo contenido es

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.chuidiang.ejemplos.android"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk android:minSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:name=".AndroidHolaMundoActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Aquí vemos algunas cosas que se pueden intuir, como versión de nuestra aplicación (versionCode es un número, versionName es lo que verá el usuario) y versión mínima de Android que necesita nuestra aplicación.

Vemos que para el icono de nuestra aplicación y su etiqueta se accede nuevamente a los recursos como @drawable/ic_launcher y @string/app_name. Ambos están en los directorios res/drawable*/ic_launcher.png y res/values/string.xml. En "Hola Mundo" hay varios directorios drawable* con distintos tamaños y resoluciones del icono, según la pantalla disponible y tamaño con que Android decida mostrarlo.

En este fichero debemos declarar todas nuestras ventanas (Activities) indicando la clase que corresponde a esa ventana y su etiqueta. La clase se pone como .AndroidHolaMundoActivity por ser su ubicación relativa al package que se ha puesto al principio del fichero package="com.chuidiang.ejemplos.android". Juntando este package con android:name obtenemos el nombre completo de la clase com.chuidiang.ejemplos.android.AndroidHolaMundoActivity. Podríamos también no poner package y situar aquí el nombre completo android:name="com.chuidiang.ejemplos.android.AndroidHolaMundoActivity".

En cuanto a intent-filter.... las ventanas android se abren cuando reciben mensajes llamados Intent. Estos mensajes sólo contienen datos que pueden resultar de interés a nuestra aplicación. En este fichero ponemos un <intent-filter> indicando qué tipos de mensajes es capaz de tratar nuestra aplicación. De esta forma, Android nos pasará estos mensajes cuando suceda algún evento u otra aplicación nos los quiera pasar. Por ejemplo, si nuestra aplicación es un editor de textos estilo notepad, un <intent-filter> podría decir que admitimos ficheros de texto para visualizar o editar. No nos compliquemos más de momento, baste saber que eso que está puesto ahora en el fichero <action android:name="android.intent.action.MAIN" /> y <category android:name="android.intent.category.LAUNCHER" /> sirve para indicar a Android que nuestra ventana es la principal de nuestra aplicación y que espera mensajes de "arranque" para visualizarse. Android llamará a esta ventana (Activity) cuando se arranque nuestra aplicación.

Y listo, vamos ahora a modificar las ventanas