Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
sgoliver.net blog
Pensamientos varios sobre programacin, Android, .NET y Java
Navigation
Despus de instalar nuestro entorno de desarrollo para Android y comentar la estructura bsica
de un proyecto y los diferentes componentes software que podemos utilizar ya es hora de empezar
a escribir algo de cdigo. Y como siempre lo mejor es empezar por escribir una aplicacin sencilla.
En un principio me plante analizar en este captulo el clsico Hola Mundo pero ms tarde me
pareci que se iban a quedar algunas cosas bsicas en el tintero. As que he versionado a mi
manera el Hola Mundo transformndolo en algo as como un Hola Usuario, que es igual de sencilla
pero aade un par de cosas interesantes de contar. La aplicacin constar de dos pantallas, por
un lado la pantalla principal que solicitar un nombre al usuario y una segunda pantalla en la que
se mostrar un mensaje personalizado para el usuario. As de sencillo e intil, pero aprenderemos
muchos conceptos bsicos, que para empezar no est mal.
Por dibujarlo para entender mejor lo que queremos conseguir, sera algo tan sencillo como lo
siguiente:
Vamos a partir del proyecto de ejemplo que creamos en un apartado anterior, al que casualmente
llamamos HolaUsuario.
Como ya vimos Eclipse haba creado por nosotros la estructura de carpetas del proyecto y todos
los ficheros necesarios de un Hola Mundo bsico, es decir, una sola pantalla donde se muestra
nicamente un mensaje fijo.
http://www.sgoliver.net/blog/?p=1316
1/26
7/2/2014
Lo primero que vamos a hacer es disear nuestra pantalla principal modificando la que Eclipse nos
ha creado por defecto. Aunque ya lo hemos comentado de pasada, recordemos dnde y cmo se
define cada pantalla de la aplicacin. En Android, el diseo y la lgica de una pantalla estn
separados en dos ficheros distintos. Por un lado, en el fichero /res/layout/activity_main.xml
tendremos el diseo puramente visual de la pantalla definido como fichero XML y por otro lado, en
el fichero /src/paquete.java/MainActivity.java, encontraremos el cdigo java que
determina la lgica de la pantalla.
Vamos a modificar en primer lugar el aspecto de la ventana principal de la aplicacin aadiendo
los controles (views) que vemos en el esquema mostrado al principio del apartado. Para ello,
vamos a sustituir el contenido del fichero activity_main.xmlpor el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/nombre" />
<EditText
android:id="@+id/TxtNombre"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:inputType="text">
</EditText>
<Button
android:id="@+id/BtnHola"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hola" />
</LinearLayout>
En este XML se definen los elementos visuales que componen la interfaz de nuestra pantalla
principal y se especifican todas sus propiedades. No nos detendremos mucho por ahora en cada
detalle, pero expliquemos un poco lo que vemos en el fichero.
Lo primero que nos encontramos es un elemento LinearLayout. Los layout son elementos no
visibles que determinan cmo se van a distribuir en el espacio los controles que incluyamos en su
interior. Los programadores java, y ms concretamente de Swing, conocern este concepto
perfectamente. En este caso, un LinearLayoutdistribuir los controles simplemente uno tras otro
y en la orientacin que indique su propiedad android:orientation, que en este caso ser
vertical.
http://www.sgoliver.net/blog/?p=1316
2/26
7/2/2014
Dentro del layout hemos incluido 3 controles: una etiqueta (TextView), un cuadro de texto
(EditText), y un botn (Button). En todos ellos hemos establecido las siguientes propiedades:
android:id. ID del control, con el que podremos identificarlo ms tarde en nuestro cdigo.
Vemos que el identificador lo escribimos precedido de @+id/. Esto tendr como efecto que
al compilarse el proyecto se genere automticamente una nueva constante en la clase Rpara
dicho control. As, por ejemplo, como al cuadro de texto le hemos asignado el ID TxtNombre,
podremos ms tarde acceder al l desde nuestro cdigo haciendo referencia a la constante
R.id.TxtNombre.
android:layout_heighty android:layout_width. Dimensiones del control con respecto
al layout que lo contiene. Esta propiedad tomar normalmente los valores wrap_content
para indicar que las dimensiones del control se ajustarn al contenido del mismo, o bien
match_parent para indicar que el ancho o el alto del control se ajustar al ancho o alto del
layout contenedor respectivamente.
Adems de estas propiedades comunes a casi todos los controles que utilizaremos, en el cuadro
de texto hemos establecido tambin la propiedad android:inputType, que indica qu tipo de
contenido va a albergar el control, en este caso texto normal (valor text), aunque podra haber
sido una contrasea (textPassword), un telfono (phone), una fecha (date), .
Por ltimo, en la etiqueta y el botn hemos establecido la propiedad android:text, que indica el
texto que aparece en el control. Y aqu nos vamos a detener un poco, ya que tenemos dos
alternativas a la hora de hacer esto. En Android, el texto de un control se puede especificar
directamente como valor de la propiedad android:text, o bien utilizar alguna de las cadenas de
texto definidas en los recursos del proyecto (como ya vimos, en el fichero strings.xml), en cuyo
caso indicaremos como valor de la propiedad android:textsu identificador precedido del prefijo
@string/. Dicho de otra forma, la primera alternativa habra sido indicar directamente el texto
como valor de la propiedad, por ejemplo en la etiqueta de esta forma:
1
2
3
4
5
<TextView
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Escribre tu nombre:" />
Y la segunda alternativa, la utilizada en el ejemplo, consistira en definir primero una nueva cadena
de texto en el fichero de recursos /res/values/strings.xml, por ejemplo con identificador
nombre y valor Escribe tu nombre:.
1
2
3
4
5
6
7
8
9
<resources>
...
<string name="nombre">Escribe tu nombre:</string>
...
</resources>
http://www.sgoliver.net/blog/?p=1316
3/26
7/2/2014
<TextView
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/nombre" />
Esta segunda alternativa nos permite tener perfectamente localizadas y agrupadas todas las
cadenas de texto utilizadas en la aplicacin, lo que nos podra facilitar por ejemplo la traduccin de
la aplicacin a otro idioma.Con esto ya tenemos definida la presentacin visual de nuestra ventana
principal de la aplicacin. De igual forma definiremos la interfaz de la segunda pantalla, creando un
nuevo fichero llamado activity_saludo.xml, y aadiendo esta vez tan solo una etiqueta
(TextView) para mostrar el mensaje personalizado al usuario.
Para aadir el fichero, pulsaremos el botn derecho del ratn sobre la carpeta de recursos
/res/layouty pulsaremos la opcin New Android XML file.
En el cuadro de dilogo que nos aparece indicaremos como tipo de recurso Layout, indicaremos
el nombre del fichero (con extensin .xml) y como elemento raz seleccionaremos LinearLayout.
Finalmente pulsamos Finish para crear el fichero.
http://www.sgoliver.net/blog/?p=1316
4/26
7/2/2014
Eclipse crear entonces el nuevo fichero y lo abrir en el editor grfico, aunque como ya
indicamos, nosotros accederemos a la solapa de cdigo para modificar directamente el contenido
XML del fichero.
Para esta segunda pantalla el cdigo que incluiramos sera el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
Una vez definida la interfaz de las pantallas de la aplicacin deberemos implementar la lgica de la
misma. Como ya hemos comentado, la lgica de la aplicacin se definir en ficheros java
independientes. Para la pantalla principal ya tenemos creado un fichero por defecto llamado
MainActivity.java. Empecemos por comentar su cdigo por defecto:
1
2
3
4
5
6
7
8
9
package net.sgoliver.android.holausuario;
import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
http://www.sgoliver.net/blog/?p=1316
5/26
7/2/2014
10
11
12
13
14
15
16
17
18
19
20
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
Como ya vimos en un apartado anterior, las diferentes pantallas de una aplicacin Android se
definen mediante objetos de tipo Activity. Por tanto, lo primero que encontramos en nuestro
fichero java es la definicin de una nueva clase MainActivityque extiende a Activity. El nico
mtodo que modificaremos de esta clase ser el mtodo onCreate(), llamado cuando se crea por
primera vez la actividad. En este mtodo lo nico que encontramos en principio, adems de la
llamada a su implementacin en la clase padre, es la llamada al mtodo
setContentView(R.layout.activity_main). Con esta llamada estaremos indicando a Android
que debe establecer como interfaz grfica de esta actividad la definida en el recurso
R.layout.activity_main, que no es ms que la que hemos especificado en el fichero
/res/layout/activity_main.xml. Una vez ms vemos la utilidad de las diferentes constantes
de recursos creadas automticamente en la clase Ral compilar el proyecto.
Adems del mtodo onCreate(), vemos que tambin se sobrescribe el mtodo
onCreateOptionsMenu(), que se utiliza para definir mens en la aplicacin. Por el momento no
tocaremos este mtodo, ms adelante en el curso nos ocuparemos de este tema.
Ahora vamos a crear una nueva actividad para la segunda pantalla de la aplicacin anloga a sta
primera, para lo que crearemos una nueva clase FrmSaludoque extienda tambin de Activityy
que implemente el mtodo onCreate()pero indicando esta vez que utilice la interfaz definida para
la segunda pantalla en R.layout.activity_saludo.
Para ello, pulsaremos el botn derecho sobre la carpeta /src/tu.paquete.java/y
seleccionaremos la opcin de men New / Class.
En el cuadro de dilogo que nos aparece indicaremos el nombre (Name) de la nueva clase y su
clase padre (Superclass) como android.app.Activity.
http://www.sgoliver.net/blog/?p=1316
6/26
7/2/2014
Pulsaremos Finish y Eclipse crear el nuevo fichero y lo abrir en el editor de cdigo java.
Modificaremos por ahora el cdigo de la clase para que quede algo anlogo a la actividad
principal:
1
2
3
4
5
6
7
8
9
10
11
12
package net.sgoliver.android.holausuario;
import android.app.Activity;
import android.os.Bundle;
public class FrmSaludo extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_saludo);
}
}
NOTA: Todos los pasos anteriores de creacin de una nueva pantalla (layout xml + clase java) se
puede realizar tambin mediante un asistente de Eclipse al que se accede mediante el men
contextual New / Other / Android / Android Activity. Sin embargo, he preferido explicarlo de esta
forma para que quedaran claros todos los pasos y elementos necesarios.
Sigamos. Por ahora, el cdigo incluido en estas clases lo nico que hace es generar la interfaz de
la actividad. A partir de aqu nosotros tendremos que incluir el resto de la lgica de la aplicacin.
Y vamos a empezar con la actividad principal MainActivity, obteniendo una referencia a los
diferentes controles de la interfaz que necesitemos manipular, en nuestro caso slo el cuadro de
texto y el botn. Para ello utilizaremos el mtodo findViewById()indicando el ID de cada
control, definidos como siempre en la clase R. Todo esto lo haremos dentro del mtodo
onCreate()de la clase MainActivity, justo a continuacin de la llamada a setContentView()
que ya comentamos:
http://www.sgoliver.net/blog/?p=1316
7/26
7/2/2014
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
...
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
...
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Obtenemos una referencia a los controles de la interfaz
final EditText txtNombre = (EditText)findViewById(R.id.TxtNombre);
final Button btnHola = (Button)findViewById(R.id.BtnHola);
...
}
...
Como vemos, hemos aadido tambin varios importadicionales para tener acceso a todas las
clases utilizadas.
Una vez tenemos acceso a los diferentes controles, ya slo nos queda implementar las acciones a
tomar cuando pulsemos el botn de la pantalla. Para ello, continuando el cdigo anterior, y
siempre dentro del mtodo onCreate(), implementaremos el evento onClickde dicho botn,
veamos cmo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
...
import android.content.Intent;
...
public class MainActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
http://www.sgoliver.net/blog/?p=1316
...
//Obtenemos una referencia a los controles de la interfaz
final EditText txtNombre = (EditText)findViewById(R.id.TxtNombre);
final Button btnHola = (Button)findViewById(R.id.BtnHola);
//Implementamos el evento click del botn
btnHola.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
//Creamos el Intent
8/26
7/2/2014
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Intent intent =
new Intent(MainActivity.this, FrmSaludo.class);
//Creamos la informacin a pasar entre actividades
Bundle b = new Bundle();
b.putString("NOMBRE", txtNombre.getText().toString());
//Aadimos la informacin al intent
intent.putExtras(b);
});
}
...
9/26
7/2/2014
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package net.sgoliver.android.holausuario;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class FrmSaludo extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_saludo);
//Localizar los controles
TextView txtSaludo = (TextView)findViewById(R.id.TxtSaludo);
//Recuperamos la informacin pasada en el intent
Bundle bundle = this.getIntent().getExtras();
Con esto hemos concluido la lgica de las dos pantallas de nuestra aplicacin y tan slo nos
queda un paso importante para finalizar nuestro desarrollo. Como ya indicamos en un apartado
anterior, toda aplicacin Android utiliza un fichero especial en formato XML
(AndroidManifest.xml) para definir, entre otras cosas, los diferentes elementos que la
componen. Por tanto, todas las actividades de nuestra aplicacin deben quedar convenientemente
recogidas en este fichero. La actividad principal ya debe aparecer puesto que se cre de forma
automtica al crear el nuevo proyecto Android, por lo que debemos aadir tan slo la segunda.
Para este ejemplo nos limitaremos a incluir la actividad en el XML mediante una nueva etiqueta
<Activity>, indicar el nombre de la clase java asociada como valor del atributo android:name, y
asignarle su ttulo mediante el atributo android:label, ms adelante veremos que opciones
adicionales podemos especificar. Todo esto lo incluiremos justo debajo de la definicin de la
actividad principal dentro del fichero AndroidManifest.xml:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="net.sgoliver.android.holausuario"
android:versionCode="1"
android:versionName="1.0" >
...
http://www.sgoliver.net/blog/?p=1316
<activity
android:name=".MainActivity"
android:label="@string/title_activity_main" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"
</intent-filter>
</activity>
<activity android:name=".FrmSaludo"
10/26
7/2/2014
19
20
21
22
23
24
25
android:label="@string/title_activity_saludo" >
</activity>
</application>
</manifest>
Como vemos, el ttulo de la nueva actividad lo hemos indicado como referencia a una nueva
cadena de caracteres, que tendremos que incluir como ya hemos comentado anteriormente en el
fichero /res/values/strings.xml
Llegados aqu, y si todo ha ido bien, deberamos poder ejecutar el proyecto sin errores y probar
nuestra aplicacin en el emulador.
La forma de ejecutar y depurar la aplicacin en Eclipse es anloga a cualquier otra aplicacin java,
pero por ser el primer captulo vamos a recordarla.
Lo primero que tendremos que hacer ser configurar un nuevo perfil de ejecucin. Para ello
accederemos al men Run/ Run Configurations y nos aparecer la siguiente pantalla.
El resto de opciones las dejaremos por defecto y pasaremos a la pestaa Target. En esta
http://www.sgoliver.net/blog/?p=1316
11/26
7/2/2014
segunda pestaa podremos seleccionar el AVD sobre el que queremos ejecutar la aplicacin,
aunque suele ser prctico indicarle a Eclipse que nos pregunte esto antes de cada ejecucin, de
forma que podamos ir alternando fcilmente de AVD sin tener que volver a configurar el perfil.
Para ello seleccionaremos la opcin Always prompt to pick device.
Un poco ms abajo en esta misma pestaa es bueno marcar la opcin Disable Boot Animation
para acelerar un poco el primer arranque del emulador, y normalmente tambin suele ser
necesario reducir, o mejor dicho escalar, la pantalla del emulador de forma que podamos verlo
completo en la pantalla de nuestro PC. Esto se configura mediante la opcin Additional Emulator
Command Line Options, donde en mi caso indicar la opcin -scale 0.75, aunque este valor
depender de la resolucin de vuestro monitor y de la configuracin del AVD.
Tras esto ya podramos pulsar el botn Run para ejecutar la aplicacin en el emulador de
Android. Eclipse nos preguntar en qu dispositivo queremos ejecutar y nos mostrar dos listas.
La primera de ellas con los dispositivos que haya en ese momento en funcionamiento (por ejemplo
si ya tenamos un emulador funcionando) y la siguiente con el resto de AVDs configurados en
nuestro entorno. Elegir en primer lugar el emulador con Android 2.2. Es posible que la primera
ejecucin se demore unos minutos, todo depender de las posibilidades de vuestro PC, as que
paciencia.
http://www.sgoliver.net/blog/?p=1316
12/26
7/2/2014
Si todo va bien, tras una pequea espera aparecer el emulador de Android y se iniciar
automticamente nuestra aplicacin. Podemos probar a escribir un nombre y pulsar el botn Hola
para comprobar si el funcionamiento es el correcto.
Sin cerrar este emulador podramos volver a ejecutar la aplicacin sobre Android 4.2
seleccionando el AVD correspondiente. De cualquier forma, si vuestro PC no es demasiado
potente no recomiendo tener dos emuladores abiertos al mismo tiempo.
http://www.sgoliver.net/blog/?p=1316
13/26
7/2/2014
Y con esto terminamos por ahora. Espero que esta aplicacin de ejemplo os sea de ayuda para
aprender temas bsicos en el desarrollo para Android, como por ejemplo la definicin de la interfaz
grfica, el cdigo java necesario para acceder y manipular los elementos de dicha interfaz, y la
forma de comunicar diferentes actividades de Android. En los apartados siguientes veremos
algunos de estos temas de forma mucho ms especfica.
Podis consultar online y descargar el cdigo fuente completo de este artculo desde github.
Curso de Programacin Android en PDF
Este curso tambin est disponible en PDF. Descubre cmo conseguirlo
Te ha sido de utilidad el Curso de Programacin Android? Quieres colaborar de forma
econmica con el proyecto? Puedes contribuir con cualquier cantidad, unos cntimos, unos
euros, cualquier aportacin ser bienvenida. Adems, si tu aportacin es superior a una
pequea cantidad simblica recibirs como agradecimiento un documento con la ltima versin
del curso disponible en formato PDF. Sea como sea, muchas gracias por colaborar!
Ms informacin:
Descubre cmo conseguir el curso en PDF
Preguntas frecuentes
Comparte esta
entrada:
Facebook 24
Twitter 12
Correo electrnico
Suscrbete
Suscrbete a alguno de nuestros canales.
http://www.sgoliver.net/blog/?p=1316
14/26
7/2/2014
Artculos Relacionados:
Un buen libro sobre programacin Android
Integracin con Google+ (II): Datos de perfil y Crculos
Integracin con Google+ (I): Google+ Sign-In
Notificaciones Push Android: Google Cloud Messaging (GCM). Implementacin Cliente (Nueva Versin)
Google Play Services: Introduccin y Preparativos
15/26
7/2/2014
16/26
7/2/2014
17/26
7/2/2014
logrado resolver se trata del setOnClickListener inicialmente lo escribi para ir interiorisando lo que iba
sucediendo pero en el momento que llegue a esta parte copie y pegue porque no me servia mira el codigo
es tal cual el que tenes ahi, me sale el sgte error:
- The type new DialogInterface.OnClickListener(){} must implement the inherited abstract method
DialogInterface.OnClickListener.onClick(DialogInterface, int)
- Line breakpoint:MainActivity [line: 25] onCreate(Bundle)
- The method setOnClickListener(View.OnClickListener) in the type View is not applicable for the
arguments (new DialogInterface.OnClickListener(){})
no se que sucede, si me podes aclarar la duda lo agradeceria mucho igualmente muchas gracias por el
tutorial
http://www.sgoliver.net/blog/?p=1316
18/26
7/2/2014
Dos dudas:
- Una, he copiado el cdigo entero y tengo un problemilla, cuando ejecuta la segunda activity, en vez de
salirme Hola me sale Hola NULL. Al parecer no lee el nombre que introduzco.
- Como descargo los cdigos fuente desde GitHub?
19/26
7/2/2014
http://www.sgoliver.net/blog/?p=1316
20/26
7/2/2014
http://www.sgoliver.net/blog/?p=1316
21/26
7/2/2014
Comentarios Anteriores
Trackbacks/Pingbacks
Tweets that mention Desarrollando una aplicacin Android sencilla | sgoliver.net blog -- Topsy.com - 16/08/2010
http://www.sgoliver.net/blog/?p=1316
22/26
7/2/2014
[...] This post was mentioned on Twitter by Babelias, Salva. Salva said: Publicado nuevo post sobre Android.
Desarrollando una aplicacin Android sencilla (http://www.sgoliver.net/blog/?p=1316) [...]
Interfaces de usuario en Android: Layouts | sgoliver.net blog - 17/08/2010
[...] el artculo anterior, donde desarrollamos una sencilla aplicacin Android desde cero, ya hicimos algunos
comentarios [...]
Desarrollo en Android | sgoliver.net blog - 27/08/2010
[...] Desarrollando una aplicacin Android sencilla [...]
Primeros pasos con Android: tutorial de App bsica | victorpascual.es - 23/02/2011
[...] idea, lo bueno y normal es hacerse un pequeo tutorial de inicio que d las bases. Ah va este:
http://www.sgoliver.net/blog/?p=1316. Veamos qu tal va la cosa. Compartir [...]
Desarrollando una aplicacin Android | Android Wireless - 30/09/2012
[...] Fuente original, creo que es el mejor tuto para iniciarse, asi pues, lo aado al portal, pero en es [...]
Componentes de una aplicacin Android | sgoliver.net blog - 23/12/2012
[...] el siguiente artculo empezaremos ya a ver algo de cdigo, analizando al detalle una aplicacin [...]
Estadsticas del blog en 2012 | sgoliver.net blog - 02/01/2013
[...] Por otro lado, las pginas ms visitadas en el ao 2012 han vuelto a ser con gran diferencia las dedicadas al
Curso de Programacin Android, especialmente el ndice de contenidos, la seccin dedicada a la obtencin del
curso en formato PDF, y los artculos iniciales sobre la instalacin y configuracin del entorno de desarrollo para
Android, la estructura de un proyecto Android, y la creacin de una aplicacin Android sencilla de ejemplo. [...]
Interfaz de usuario en Android: Widgets (II) | sgoliver.net blog - 18/04/2013
[...] Este ID nos llega como parmetro del intent que ha lanzado la actividad. Como ya vimos en un artculo anterior
del curso, este intent se puede recuperar mediante el mtdo getIntent() y sus parmetros mediante [...]
Deja un comentario
Name (required)
Email (w ill not be published) (required)
Website
Enviar Comentario
Buscar...
http://www.sgoliver.net/blog/?p=1316
23/26
7/2/2014
Publicidad
Sguenos!
Suscrbete a alguno de nuestros canales.
Licencia del Blog
Salvador Gmez Oliver. Todos los derechos reservados.
Queda prohibida la reproduccin total o parcial de los contenidos de este blog, as como su uso y difusin, sin el
consentimiento previo de su autor.
Por favor, respeta los derechos de autor. Si quieres emplear alguno de los textos o imgenes de este blog
puedes solicitarlo por correo electrnico a la direccin indicada en la seccin de contacto.
Publicidad
http://www.sgoliver.net/blog/?p=1316
24/26
7/2/2014
Archivo
Elegir mes
Categoras
Elegir categora
Etiquetas
.NET actualizacin ajedrez antlr base de datos blog C# C++ compiladores controles
curso
http://www.sgoliver.net/blog/?p=1316
7/2/2014
FKScript google gratis herramienta IA java JRtfTree librera libro manuales mapas Mono
mquinas virtuales NChess novedades novedades sgoliver.net
plugin programacin RTF SAX SQlite tutoriales web
Enlaces .NET
el Guille La Web de Visual Basic, C#, .NET y ms
Enlaces Android
AndDev.org [Ingls]
Androcode
http://www.sgoliver.net/blog/?p=1316
26/26