Tema 3. Desarrollo de Una Aplicacion Sencilla

CURSO DE DESARROLLO DE APLICACIONES ANDROID
Tema 3
Desarrollo de una Aplicación Sencilla

TEMA 3. DESARROLLO DE UNA APLICACIÓN SENCILLA
Desarrollo de una aplicación sencilla
En este tema se mostrará paso a paso cómo desarrollar una sencilla aplicación Android, que
aplicará parte de los conceptos básicos explicados en los temas anteriores.
La aplicación simplemente solicitará al usuario que pulse en cualquier punto de la pantalla

para, a continuación, mostrar dónde ha pulsado y durante cuánto tiempo se ha mantenido la
pulsación.
Para implementar esta funcionalidad, será necesario crear dos actividades, clases que
extienden a Activity, así como sus correspondientes archivos XML de layout. Además, será
necesario modificar el archivo strings.xml.
Es importante recordar que, en las aplicaciones Android, para crear una pantalla, se necesitará
una actividad y un layout 1. La actividad es una clase Java en la que se implementa la
funcionalidad de la pantalla, mientras que el layout es un archivo XML que contiene el diseño
de la misma.
Creación del proyecto en Eclipse
El primer paso para desarrollar la aplicación es, evidentemente, crear un nuevo proyecto
Android en el entorno de desarrollo Eclipse, que deberá tener instalado el plugin ADT (Android
Development Tools). Además, será necesario haber instalado correctamente todas las
versiones de la SDK de Android con la herramienta SDK Manager, así como haber configurado
al menos un AVD (Android Virtual Device) con la herramienta AVD Manager.
En Eclipse, se accederá al menú File > New > Other.. > Android > Android Application Project y
se creará el proyecto “AplicacionSencilla”, tal y como muestra la siguiente imagen:
1
También se podrán usar fragmentos, tal y como se verá en un próximo tema.
CURSO DE DESARROLLO DE APLICACIONES ANDROID 2

En este cuadro de diálogo, el nombre de la aplicación será el que se muestre debajo del icono
de la aplicación, en el dispositivo. El nombre del proyecto, que no tiene por qué coincidir con el
de la aplicación, será el nombre de la carpeta (dentro del Workspace de Eclipse), que
contendrá todos los archivos del proyecto. El nombre del paquete (Package Name) será el
nombre del paquete principal de la aplicación, donde en general se ubicarán las actividades, y
que quedará reflejado en el atributo android:package del manifiesto de la aplicación. Dicho
nombre de paquete será utilizado por ADT para ubicar correctamente las clases R.java y
BuildConfig.java.
El resto de opciones no serán modificadas. La SDK mínima requerida (atributo

android:minSdkVersion en el manifiesto) limita la versión de Android mínima requerida en el
dispositivo para que la aplicación pueda ser instalada (y que utilizará Google Play para filtrar
las aplicaciones en las búsquedas realizadas desde los dispositivos, en función de su nivel de
API). La SDK objetivo (Target SDK), representa la versión de la SDK de Android con la que se ha
probado la aplicación. Indica al sistema que no debe activar ningún comportamiento de
compatibilidad para que la aplicación funcione correctamente. En dispositivos con versiones
de Android comprendidas entre la SDK mínima requerida y la SDK objetivo, el sistema activará
dichos comportamientos de compatibilidad para garantizar que la aplicación funciona
correctamente. Compile Width indica la versión de Android con la cual será compilada la
aplicación. Por último, Theme establecerá el estilo general de la aplicación.
Se ha de tener en cuenta que el AVD que se haya creado deberá tener un Target igual o
superior al de la aplicación que se va a desarrollar.

Al pulsar Next tres veces más, se mostrarán las siguientes configuraciones:

Por último, se solicitará el nombre de la actividad principal del proyecto, así como de su layout.

Esta actividad será invocada por el sistema cuando la aplicación sea iniciada, gracias al intent-
filter que contendrá en el manifiesto:
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
Tal y como se verá en profundidad en un próximo tema, este filtro permite, además, que la
aplicación sea mostrada en la lista de aplicaciones instaladas en el dispositivo (el Launcher).
Al pulsar Finish, Eclipse creará la estructura del proyecto, y generará la actividad principal,
MainActivity.java, y su correspondiente layout, activity_main.xml, además de otros archivos:

Diseño de la interfaz de usuario de la aplicación
Al crear el proyecto, Eclipse abre automáticamente el archivo de layout activity_main.xml, en

la Vista de diseño (modo “Graphical Layout”). Esta pestaña permite construir las pantallas de la
aplicación de forma gráfica, tal y como puede apreciarse en la siguiente imagen.
Pese a que este modo de diseño es muy útil para construir las pantallas, el código XML será
generado automáticamente por Eclipse (contenido en el layout activity_main.xml). Es
recomendable utilizar la Vista de código para editar directamente el XML.
La primera pantalla que se mostrará al usuario solicitará a este, a través de un TextView, que
pulse en la pantalla. Para ello, una vez abierta la Vista de código del layout principal de la
aplicación, activity_main.xml, se sustituirá el código que automáticamente ha generado
Eclipse, por el siguiente2:
2
ATENCIÓN: no se debe copiar en Eclipse directamente el código de ejemplo mostrado en los temas, puesto que se
copiarán multitud de caracteres especiales e invisibles (tabulaciones, etc.) que harán que el código no compile. Es
necesario escribir manualmente en Eclipse todo el código mostrado en los ejemplos.

Código de res/layout/activity_main.xml
<LinearLayout 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"
android:orientation="vertical"
tools:context=".MainActivity" >
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/textoAccion" />
</LinearLayout>
La estructura de este código será explicada en los próximos temas. Por el momento, cabe
resaltar los siguientes conceptos:
1. La disposición de los elementos contenidos en la pantalla se establece mediante un

tipo de layout concreto. En este caso, se utiliza un LinearLayout¸ el cual dispondrá
todos los elementos uno a continuación del otro, siguiendo una orientación vertical
(android:orientation="vertical").
2. El único control que contiene la pantalla es un TextView. Dicho control permite
mostrar cadenas de texto en la pantalla de la aplicación. En este control, se observan
dos importantes propiedades:
a. android:id="@+id/textView". Con esta propiedad se identifica
unívocamente al control en la aplicación, de forma que sea accesible desde su
actividad (parte Java). Para acceder al control, bastará invocar al método
findViewById(), pasando como parámetro la referencia contenida en la clase
R: R.id.textView.
b. android:text="@string/textoAccion". Con esta propiedad se parametriza
la cadena de texto que por defecto contendrá el control, con el objeto de
unificar en un solo archivo XML todos los textos de la aplicación, haciendo así
más fácil, por ejemplo, cambiar de idioma. Este archivo se llama strings.xml y
se ubica en la carpeta del proyecto “/res/values”.
Al añadir esta propiedad, Eclipse la subrayará de rojo, indicando que existe un
error (que mostrará al posicionar el puntero del ratón sobre el texto
subrayado), ya que el recurso textoAccion no ha sido aún declarado en
strings.xml. Una forma rápida de añadir el recurso consiste en posicionar el
cursor sobre el texto en subrayado en rojo y pulsar Ctrl+1 (o pulsar sobre dicho
texto con el botón derecho del ratón y elegir la opción “Quick Fix”). Aparecerá
un menú con posibles soluciones al error, siendo en general la primera opción,
la que corrige el error. Eligiendo "Create resource @string/textoAccion", se
abrirá automáticamente el archivo strings.xml y Eclipse añadirá lo siguiente:
<string name="textoAccion">TODO</string>

Se sustituirá el valor del recurso textoAccion por el siguiente:
<string name="textoAccion">Pulsa en la pantalla...</string>
A continuación, se creará la segunda actividad, así como su layout. Para ello, se pulsará con el
botón derecho del ratón sobre el proyecto para acceder a “New > Other > Android… > Android
Activity”:

Al pulsar Next, se mostrará una tercera pantalla en la cual se introducirá el nombre de la

actividad, así como el de su archivo XML de layout:
Pulsando por última vez Next, Eclipse mostrará una nueva pantalla en la que se enumeran los
cambios que se introducirán en otros archivos del proyecto, como consecuencia de añadir esta

nueva actividad (por ejemplo, se muestra la modificación del manifiesto de la aplicación para
incluir la nueva actividad):
Al pulsar Finish, Eclipse creará el archivo ResultsActivity.java dentro del paquete principal de la
aplicación (en la carpeta “/src”), así como el archivo activity_results.xml que ubicará en la
carpeta “/res/layout”. Además, abrirá este último archivo en la Vista de código. En dicha vista
se añadirán dos TextView que mostrarán la información que será recogida en la primera
pantalla, y que será enviada desde la primera actividad a la segunda actividad (tal y como se
verá a continuación):

Código de res/layout/activity_results.xml
<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
tools:context=".ResultsActivity" >
<TextView
android:id="@+id/textView1"
android:text="@string/resultados1" />
<TextView
android:id="@+id/textView2"
android:text="@string/resultados2" />
</LinearLayout>
De nuevo, Eclipse subrayará de rojo los recursos aún no declarados en strings.xml,

resultados1 y resultados2. Se deberán añadir dichos recursos al archivo, que finalmente
quedará así:
Código de res/values/strings.xml
<?xml version="1.0" encoding="utf-8"?>

<resources>
<string name="app_name">T03-AplicacionSencilla</string>
<string name="hello_world">Hello world!</string>
<string name="menu_settings">Settings</string>
<string name="textoAccion">Pulsa en la pantalla...</string>
<string name="resultados1">
Este texto será sustituido desde la actividad
</string>
<string name="resultados2">
Este texto será sustituido desde la actividad
</string>
</resources>

Cómo crear un archivo XML de layout
El plugin ADT contiene un asistente para crear archivos XML de diferentes tipos (archivos de
layout, de propiedades, para definir menús, drawables, animaciones, etc.).
Para crear un archivo XML de layout, se pulsará con el botón derecho del ratón sobre el
proyecto y se accederá a “New > Android XML File” y se seleccionará Layout en la opción
Resource Type:
Una vez añadido el nombre del archivo de layout, new_layout.xml, se establecerá como
elemento raíz (Root Element) para el layout, un LinearLayout y se pulsará Next.

Al pulsar Finish, Eclipse creará el archivo new_layout.xml en la carpeta “/res/layout”, y lo

abrirá en la Vista de código.

Implementación de la funcionalidad de la aplicación
Hasta este punto, lo único que se ha hecho ha sido crear la interfaz de usuario (UI, User
Interface) de dos sencillas pantallas a través de dos archivos XML de layout, y se han declarado
las dos actividades que gestionarán las pantallas. Ahora, se deberá implementar la
funcionalidad de la aplicación en las actividades asociadas a cada una de estas pantallas.
Cuando Eclipse, con la ayuda del plugin ADT, crea las actividades, genera el código que
construye la UI a través del layout (método onCreate()) y el que construye el menú de la
pantalla (método onCreateOptionsMenu()). Por ejemplo, en el caso de MainActivity.java,
genera el siguiente código:
Código de src/MainActivity.java recién creado por ADT
package com.cursoandroid.ui;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is
// present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
A continuación, se añadirá el código necesario en las actividades, que implementará la

funcionalidad necesaria para la aplicación.
El código completo de la clase MainActivity será el siguiente:

Código de src/MainActivity.java
import java.util.Calendar;
import android.content.Intent;
import android.view.MotionEvent;
public class MainActivity extends Activity {

@Override
setContentView(R.layout.activity_main);
}
@Override
// present.
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
Calendar tiempoInicio = null;

Calendar tiempoFinal = null;
@Override
public boolean onTouchEvent(MotionEvent event) {
int x = (int) event.getX();

int y = (int) event.getY();
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
tiempoInicio = Calendar.getInstance();
break;
case MotionEvent.ACTION_MOVE:
break;
case MotionEvent.ACTION_UP:
tiempoFinal = Calendar.getInstance();
Intent intent = new Intent(this, ResultsActivity.class);
Bundle bundle = new Bundle();
bundle.putLong("TIEMPOPRESIONADO",
tiempoFinal.getTimeInMillis()-
tiempoInicio.getTimeInMillis());
bundle.putInt("X", x);
bundle.putInt("Y", y);
intent.putExtras(bundle);
startActivity(intent);
break;
}
return true;
}
}

Como se puede observar, existen los dos métodos ya mencionados, onCreate() y

onCreateOptionsMenu() que han de sobreescribir (@Override) los correspondientes
métodos heredados de la clase Activity, y un tercer método, que también sobreescribe el de
Activity, onTouchEvent().
• Método onCreate(Bundle savedInstanceState)

Este método inicializa la pantalla y establece la interfaz visual al invocar a
setContentView(R.layout.activity_amin), sentencia que asigna el layout
activity_main.xml (ubicado en “/res/layout”) a través de su referencia en la clase R.
• Método onCreateOptionsMenu(Menu menu)
Este método inicializa el menú de la pantalla a través del archivo XML
activity_main.xml que define el menú, ubicado en “/res/menu”, a través de su
referencia en la clase R. Este método devuelve un valor booleano. En caso de devolver
true, el menú será mostrado, y no será mostrado si devuelve false.
• Método onTouchEvent(MotionEvent event)
Este método se puede sobreescribir al heredarlo de Activity para implementar
acciones en función de las interacciones tipo touch que realice el usuario en la
pantalla. En este caso, cada vez que se capture el evento, se recogerán las
coordenadas X e Y del punto de la pantalla que haya tocado el usuario
(event.getX(); event.getY()). A continuación, se analiza el tipo de evento de
pulsación (presionando, deslizando o levantando el dedo). En caso de que se esté
presionando el dedo, se almacena la marca de tiempo (tiempoInicio =
Calendar.getInstance()). En caso de que se haya levantado, se vuelve a almacenar
la marca de tiempo (tiempoFin = Calendar.getInstance()) para poder calcular
cuántos milisegundos se ha estado presionando la pantalla
(tiempoFinal.getTimeInMillis() - tiempoInicio.getTimeInMillis()).
A continuación se crean dos instancias de dos componentes (clases) muy importantes:
Intent y Bundle.
Tal y como se comentó en el tema anterior, un Intent generará un mensaje en el
sistema que comunicará la intención que tiene esta actividad (this) de iniciar la
siguiente actividad de la aplicación (ResultsActivity):
Intent intent = new Intent(this, ResultsActivity.class);
Como se quiere enviar información a la segunda actividad, se creará un objeto de tipo

Bundle que permite almacenar pares clave-valor, para enviar como extras, a través
del Intent:

Bundle bundle = new Bundle();

bundle.putLong(
"TIEMPOPRESIONADO",
tiempoFinal.getTimeInMillis() -
tiempoInicio.getTimeInMillis());
bundle.putInt("X", x);
bundle.putInt("Y", y);
intent.putExtras(bundle);
Por último, se inicia la siguiente actividad a través Intent:
startActivity(intent);
A continuación, se tendrá que modificar el código de la segunda actividad ResultsActivity, para

que muestre los datos que recibe a través del Intent.
Código de src/ResultsActivity.java
import android.widget.TextView;
public class ResultsActivity extends Activity {

@Override
setContentView(R.layout.activity_results);
Bundle bundle = getIntent().getExtras();

float segundosPresionado =
bundle.getLong("TIEMPOPRESIONADO") / 1000f;
TextView txtMensaje1 = (TextView) findViewById(R.id.textView1);

txtMensaje1.setText("Has pulsado la pantalla durante "

+ segundosPresionado + " segundos");
txtMensaje2.setText("Has pulsado en las coordenadas ("
+ bundle.getInt("X") + ", " + bundle.getInt("Y") + ")");
}
@Override
// present.
getMenuInflater().inflate(R.menu.activity_results, menu);
return true;
}
}

Esta actividad es más sencilla, ya que solo implementa el método onCreate() que accederá al
Bundle contenido en el Intent que ha iniciado esta actividad para extraer los valores que
contiene, a través de las claves establecidas:
Bundle bundle = getIntent().getExtras();

…
bundle.getLong("TIEMPOPRESIONADO")
bundle.getInt("X")
bundle.getInt("Y")
Para poder mostrar en pantalla la información recogida, es necesario obtener una referencia
de los controles TextView del layout asociado. Esto se consigue invocando al método
findViewById():

Y, por último, se utilizarán los valores obtenidos del Bundle para componer los textos que se
mostrarán al usuario a través de los controles TextView:
txtMensaje1.setText("Has pulsado la pantalla durante " +

segundosPresionado + "segundos");
txtMensaje2.setText("Has pulsado en las coordenadas (" +
bundle.getInt("X") + ", " + bundle.getInt("Y") + ")");
Como ya se ha mencionado anteriormente, es necesario declarar todos los recursos de tipo

String que correspondan a cadenas de texto que se muestran al usuario, en el archivo
strings.xml, con el objetivo principal de facilitar el multiidioma de la aplicación. En la porción
de código mostrada más arriba, existen cadenas de texto (texto en azul) que deben sustituirse
por referencias a recursos del archivo strings.xml. Ya se ha visto que dichas referencias se
insertan con @string/recurso_string en los archivos de layout XML (y en otros). En las
actividades, y otras clases Java, se puede referenciar a estos recursos a través de
R.string.recurso_string.
Eclipse, con la ayuda del plugin ADT, permite añadir automáticamente estas cadenas de texto
al archivo strings.xml. Para ello, bastará con seleccionar la cadena de texto, pulsar Ctrl+1 y
elegir la opción Extract String del menú contextual 3. Al realizar esta acción sobre el texto
seleccionado "Has pulsado la pantalla durante ", se mostrará el siguiente cuadro de
diálogo:
3
También se podrá acceder a través del menú de Eclipse “Refactor > Android > Extract Android String…”

Después de modificar el nombre del recurso por R.string.pulsado_durante (para abreviar

y hacer el código más legible) se podrá elegir sustituir dicha cadena de texto en todos los
archivos Java y XML del proyecto, así como previsualizar la modificación que se introducirá en
cada uno de los archivos.
Al pulsar OK, Eclipse realizará la siguiente modificación sobre el código previamente

seleccionado:
txtMensaje1.setText(R.string.pulsado_durante + segundosPresionado + "

segundos");
Actualmente, el plugin ADT presenta un pequeño problema, que se solventará en una futura
versión. La sustitución que genera no tiene en cuenta que el String que se ha sustituido
puede estar concatenado con otros. El método setText() es polimórfico y admite tanto una
referencia de la clase R (un valor entero, int) como, directamente, un String (simple o
producto de una concatenación). El plugin solo proporciona la primera opción (el valor entero
de la clase R) por lo que, si se quiere crear un String concatenado, se deberá pasar dicha

referencia al método de contexto 4 getString(), el cual devuelve un objeto de tipo String

inicializado con el contenido del recurso:
txtMensaje1.setText(getString(R.string.pulsado_durante) +
segundosPresionado + " segundos");
Gracias al método de contexto getString(), se pueden concatenar diversos recursos de tipo

String (declarados en strings.xml) con otros valores dinámicos extraídos de la aplicación.
Si se realizan el resto de sustituciones, la porción de código acabará así:
txtMensaje1.setText(getString(R.string.pulsado_durante)
+ segundosPresionado + getString(R.string.segundos));
txtMensaje2.setText(getString(R.string.pulsado_en_coordenadas)
+ bundle.getInt("X") + ", " + bundle.getInt("Y") + ")");
Existe, no obstante, otra forma más eficiente de crear un String dinámico, basado en la
inyección de parámetros en un String declarado en strings.xml con el método estático
String.format(). Por ejemplo, se puede declarar el siguiente recurso String:
<string name="string_con_parametros">
Esto es un string que tiene dos parámetros. En el primero pone: %1$s,
y en el segundo pone %2$s
</string>
En la actividad, se usará así (se supone que el layout contiene un EditText con identificador
editText):
EditText editText = (EditText) findViewById(R.id.editText);

String textoFormateado = String.format(
getString(R.string.string_con_parametros), "234", editText.getText());
Si, en el EditText editText, se ha escrito "Hola Mundo", el valor de textoFormateado será:
"Esto es un string que tiene dos parámetros. En el primero pone: 234, y en el segundo pone
Hola Mundo"
4
Las aplicaciones Android incluyen un contexto, espacio representado por la clase Context de la cual hereda
Activity. El método getString(R.string.recurso_string) es un método de Context, accesible por lo tanto en
las actividades.

Además, también se deberán definir los String[] en strings.xml:
<string-array name="opciones">
<item>Opción 1</item>
<item>Opción 2</item>
<item>...</item>
</string-array>
Dichos String[] serán inicializados a través del método de contexto getResources():
String[] opciones = getResources().getStringArray(R.array.opciones);
Declaración de actividades en el manifiesto
En el tema anterior se habló del archivo AndroidManifiest.xml, el cual es fundamental en toda

aplicación Android. En dicho archivo deben quedar declaradas todas las actividades, servicios,
receptores de broadcast, proveedores de contenido, permisos de usuario, librerías adicionales
usadas, etc.
Cuando se crean actividades en Eclipse a través del procedimiento mencionado previamente,

el plugin ADT se encarga de declararlas automáticamente en el manifiesto de la aplicación.
Pero, en el caso de que se cree una actividad de forma manual, o bien se copie una ya
existente, se deberá añadir en el manifiesto un elemento <activity> (dentro de
<application>):
<activity android:name="NewActivity">
…
</activity>
El contenido de el elemento variará en función de las necesidades de dicha actividad, y podrá

contener diversos filtros (intent-filters), tal y como se verá en un próximo tema.
Ejecución de la aplicación en AVD
La aplicación será probada en un ADV previamente configurado. Para ejecutarla, bastará con
seleccionar la actividad principal de la aplicación, MainActivity, o la raiz del proyecto en la vista
Package Explorer, pulsar el botón Run de Eclipse, , y elegir Run as Android Application:

Al pulsar OK, se mostrará un cuadro de diálogo que permitirá elegir entre los dispositivos
reales que estén conectados y que la herramienta adb haya detectado 5:
Una vez seleccionado un AVD disponible, se pulsará OK. Eclipse cargará el AVD y lanzará la
aplicación, mostrando la siguiente pantalla:
5
Estos dispositivos estarán conectados vía USB y deberán tener la opción Depuración USB activada en el menú
Ajustes > Opciones de desarrollo. Se pueden incluso conectar dispositivos vía WiFi si se activa la opción ADB sobre
TCP/IP y se configura la herramienta adb en dicho modo, con el comando adb tcpip:5555 (donde 5555 es el puerto
sobre el que se conectará).

Si se realiza una pulsación con el ratón en cualquier punto de la pantalla durante un lapso de
tiempo, al levantar el dedo (del ratón), la aplicación mostrará la segunda pantalla, con la
información capturada:

Tema 3. Desarrollo de Una Aplicacion Sencilla

Diunggah oleh

Informasi Dokumen

Hak Cipta

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Tema 3. Desarrollo de Una Aplicacion Sencilla

Diunggah oleh

Hak Cipta:

CURSO DE DESARROLLO DE APLICACIONES ANDROID

Desarrollo de una Aplicación Sencilla

Desarrollo de una aplicación sencilla

La aplicación simplemente solicitará al usuario que pulse en cualquier punto de la pantalla

Creación del proyecto en Eclipse

CURSO DE DESARROLLO DE APLICACIONES ANDROID 2

El resto de opciones no serán modificadas. La SDK mínima requerida (atributo

CURSO DE DESARROLLO DE APLICACIONES ANDROID 3

Al pulsar Next tres veces más, se mostrarán las siguientes configuraciones:

CURSO DE DESARROLLO DE APLICACIONES ANDROID 4

CURSO DE DESARROLLO DE APLICACIONES ANDROID 5

CURSO DE DESARROLLO DE APLICACIONES ANDROID 6

Diseño de la interfaz de usuario de la aplicación

Al crear el proyecto, Eclipse abre automáticamente el archivo de layout activity_main.xml, en

CURSO DE DESARROLLO DE APLICACIONES ANDROID 7

1. La disposición de los elementos contenidos en la pantalla se establece mediante un

CURSO DE DESARROLLO DE APLICACIONES ANDROID 8

Se sustituirá el valor del recurso textoAccion por el siguiente:

<string name="textoAccion">Pulsa en la pantalla...</string>

CURSO DE DESARROLLO DE APLICACIONES ANDROID 9

Al pulsar Next, se mostrará una tercera pantalla en la cual se introducirá el nombre de la

CURSO DE DESARROLLO DE APLICACIONES ANDROID 10

CURSO DE DESARROLLO DE APLICACIONES ANDROID 11

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

De nuevo, Eclipse subrayará de rojo los recursos aún no declarados en strings.xml,

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

CURSO DE DESARROLLO DE APLICACIONES ANDROID 12

Cómo crear un archivo XML de layout

CURSO DE DESARROLLO DE APLICACIONES ANDROID 13

Al pulsar Finish, Eclipse creará el archivo new_layout.xml en la carpeta “/res/layout”, y lo

CURSO DE DESARROLLO DE APLICACIONES ANDROID 14

Implementación de la funcionalidad de la aplicación

Código de src/MainActivity.java recién creado por ADT

public class MainActivity extends Activity {

A continuación, se añadirá el código necesario en las actividades, que implementará la

El código completo de la clase MainActivity será el siguiente:

CURSO DE DESARROLLO DE APLICACIONES ANDROID 15

public class MainActivity extends Activity {

Calendar tiempoInicio = null;

int x = (int) event.getX();

CURSO DE DESARROLLO DE APLICACIONES ANDROID 16

Como se puede observar, existen los dos métodos ya mencionados, onCreate() y

• Método onCreate(Bundle savedInstanceState)

Intent intent = new Intent(this, ResultsActivity.class);

Como se quiere enviar información a la segunda actividad, se creará un objeto de tipo

CURSO DE DESARROLLO DE APLICACIONES ANDROID 17

Bundle bundle = new Bundle();

Por último, se inicia la siguiente actividad a través Intent:

A continuación, se tendrá que modificar el código de la segunda actividad ResultsActivity, para

public class ResultsActivity extends Activity {

Bundle bundle = getIntent().getExtras();

TextView txtMensaje1 = (TextView) findViewById(R.id.textView1);

txtMensaje1.setText("Has pulsado la pantalla durante "

CURSO DE DESARROLLO DE APLICACIONES ANDROID 18

Bundle bundle = getIntent().getExtras();

TextView txtMensaje1 = (TextView) findViewById(R.id.textView1);

txtMensaje1.setText("Has pulsado la pantalla durante " +

Como ya se ha mencionado anteriormente, es necesario declarar todos los recursos de tipo

CURSO DE DESARROLLO DE APLICACIONES ANDROID 19

Después de modificar el nombre del recurso por R.string.pulsado_durante (para abreviar

Al pulsar OK, Eclipse realizará la siguiente modificación sobre el código previamente

txtMensaje1.setText(R.string.pulsado_durante + segundosPresionado + "

CURSO DE DESARROLLO DE APLICACIONES ANDROID 20

referencia al método de contexto 4 getString(), el cual devuelve un objeto de tipo String

Gracias al método de contexto getString(), se pueden concatenar diversos recursos de tipo

Si se realizan el resto de sustituciones, la porción de código acabará así:

EditText editText = (EditText) findViewById(R.id.editText);