Académique Documents
Professionnel Documents
Culture Documents
(Android Studio)
16/01/2015 por sgoliver 46 Comentarios
El ritmo de actualizaciones de Android Studio es bastante alto, por lo que algunos detalles de este artculo pueden no ajustarse exactamente a la
ltima versin de la aplicacin. Este artculo se encuentra actualizado para la versin de Android Studio 1.3.1
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 Hola Usuario.
Como ya vimos Android Studio 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.
Lo primero que vamos a hacer es disear nuestra pantalla principal modificando la que Android Studio 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 /src/main/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/main/java/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.xml por el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/LytContenedor"
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" />
<Button android:id="@+id/BtnAceptar"
15
16
android:layout_width="wrap_content"
17
android:layout_height="wrap_content"
18
android:text="@string/aceptar" />
19
20
</LinearLayout>
21
22
Al pegar este cdigo en el fichero de layout aparecern algunos errores marcados en rojo, en los valores de los atributos android:text. Es
normal, lo arreglaremos pronto.
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 LinearLayout distribuir los controles simplemente uno tras otro y en la orientacin que indique
su propiedad android:orientation, que en este caso ser vertical.
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 R para 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_height y android:layout_width. Dimensiones del control con respecto al layout que lo contiene
(height=alto, width=ancho). 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 alto o
ancho 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 ser texto normal (valor text),
aunque podra haber sido una contrasea (valor 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:text su 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
<TextView
2
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
3
android:layout_height="wrap_content"
4
android:text="Escribe tu nombre:" />
5
Y la segunda alternativa, la utilizada en el ejemplo, consistira en definir primero una nueva cadena de texto en el fichero de
recursos /src/main/res/values/strings.xml, por ejemplo con identificador nombre y valor Escribe tu nombre:.
1
2
3
4
<resources>
...
<string name="nombre">Escribe tu nombre:</string>
...
</resources>
5
Y posteriormente indicar el identificador de la cadena como valor de la propiedad android:text, siempre precedido del prefijo
@string/, de la siguiente forma:
1
<TextView
2
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
3
android:layout_height="wrap_content"
4
android:text="@string/nombre" />
5
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. Haremos esto para las dos cadenas de texto utilizadas en el layout,
nombre y aceptar. Una vez incluidas ambas cadenas de texto en el fichero strings.xml deberan desaparecer los dos errores marcados en rojo
que nos aparecieron antes en la ventanaactivity_main.xml.
Con esto ya tenemos definida la presentacin visual de nuestra ventana principal de la aplicacin, veamos ahora 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
10
11
package net.sgoliver.android.holausuario;
import
import
import
import
import
import
android.content.Intent;
android.support.v7.app.AppCompatActivity;
android.os.Bundle;
android.view.Menu;
android.view.MenuItem;
android.view.View;
12
13
14
protected void onCreate(Bundle savedInstanceState) {
15
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
16
}
17
18
@Override
19
public boolean onCreateOptionsMenu(Menu menu) {
20
// Inflate the menu; this adds items to the action bar if it is present.
21
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
22
}
23
24
@Override
25
public boolean onOptionsItemSelected(MenuItem item) {
26
// Handle action bar item clicks here. The action bar will
27
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
28
int id = item.getItemId();
29
30
//noinspection SimplifiableIfStatement
31
if (id == R.id.action_settings) {
32
return true;
}
33
34
return super.onOptionsItemSelected(item);
35
}
36
}
37
38
39
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 MainActivity que extiende en este caso de un
tipo especial de Activity llamado ActionBarActivity, que soporta la utilizacin de laAction Bar en nuestras aplicaciones (la action
bar es la barra de ttulo y men superior que se utiliza en la mayora de aplicaciones Android). El nico mtodo que modificaremos por ahora 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 /src/main/res/layout/activity_main.xml. Una vez ms vemos la utilidad de las diferentes constantes de recursos creadas
automticamente en la clase R al compilar el proyecto.
Adems del mtodo onCreate(), vemos que tambin se sobrescriben los
mtodos onCreateOptionsMenu() y onOptionsItemSelected(), que se utilizan para definir y gestionar los mens de la aplicacin
y/o las opciones de la action bar. Por el momento no tocaremos estos mtodos, ms adelante en el curso nos ocuparemos de estos temas.
Antes de modificar el cdigo de nuestra actividad principal, vamos a crear una nueva actividad para la segunda pantalla de la aplicacin anloga
a sta primera, a la que llamaremos SaludoActivity.
Para ello, pulsaremos el botn derecho sobre la carpeta /src/main/java/tu.paquete.java/ y seleccionaremos la opcin de men New / Activity /
Blank Activity.
En el cuadro de dilogo que aparece indicaremos el nombre de la actividad, en nuestro casoSaludoActivity, el nombre de su layout XML
asociado (Android Studio crear al mismo tiempo tanto el layout XML como la clase java), que llamaremos activity_saludo, el ttulo de la
actividad que aparecer en la action bar. El resto de opciones las podemos dejar por ahora con sus valores por defecto.
Pulsaremos Finish y Android Studio crear los nuevos ficheros SaludoActivity.java yactivity_saludo.xml en sus carpetas
correspondientes.
De igual forma que hicimos con la actividad principal, definiremos en primer lugar la interfaz de la segunda pantalla, abriendo el
fichero activity_saludo.xml, y aadiendo esta vez tan slo unLinearLayout como contenedor y una etiqueta (TextView) para mostrar el
mensaje personalizado al usuario.
Para esta segunda pantalla el cdigo que incluiramos sera el siguiente:
1
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
2
android:id="@+id/LytContenedorSaludo"
3
android:layout_width="match_parent"
4
android:layout_height="match_parent"
android:orientation="vertical" >
5
6
<TextView android:id="@+id/TxtSaludo"
7
android:layout_width="wrap_content"
8
android:layout_height="wrap_content"
9
android:text="" />
10
11
</LinearLayout>
12
Por su parte, si revisamos ahora el cdigo de la clase java SaludoActivity veremos que es anlogo a la actividad principal:
1
2
3
4
5
6
7
8
9
10
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 definiremos ambas referencias como atributos de la clase y
para obtenerlas 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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package net.sgoliver.android.holausuario;
//...
import android.widget.Button;
import android.widget.EditText;
public class MainActivity extends AppCompatActivity {
private EditText txtNombre;
private Button btnAceptar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//...
20
21
}
22
23
Como vemos, hemos aadido tambin varios import adicionales (los de las clases Button yEditText) 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 onClick de dicho botn.
Este botn tendr que ocuparse de abrir la actividad SaludoActivity pasndole toda la informacin necesaria. Veamos cmo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package net.sgoliver.android.holausuario;
//...
import android.content.Intent;
public class MainActivity extends AppCompatActivity {
private EditText txtNombre;
private Button btnAceptar;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Obtenemos una referencia a los controles de la interfaz
txtNombre = (EditText)findViewById(R.id.TxtNombre);
btnAceptar = (Button)findViewById(R.id.BtnAceptar);
//Implementamos el evento click del botn
btnAceptar.setOnClickListener(new View.OnClickListener() {
19
20
21
@Override
22
public void onClick(View v) {
23
//Creamos el Intent
24
Intent intent =
25
new Intent(MainActivity.this, SaludoActivity.class);
26
//Creamos la informacin a pasar entre actividades
27
Bundle b = new Bundle();
28
b.putString("NOMBRE", txtNombre.getText().toString());
29
30
//Aadimos la informacin al intent
31
intent.putExtras(b);
32
33
//Iniciamos la nueva actividad
startActivity(intent);
34
}
35
});
36
}
37
38
//...
}
39
40
41
42
Como ya indicamos en el apartado anterior, la comunicacin entre los distintos componentes y aplicaciones en Android se realiza
mediante intents, por lo que el primer paso es crear un objeto de este tipo. Existen varias variantes del constructor de la clase Intent, cada una
de ellas dirigida a unas determinadas acciones. En nuestro caso particular vamos a utilizar el intent para iniciar una actividad desde otra
actividad de la misma aplicacin, para lo que pasaremos a su constructor una referencia a la propia
actividad llamadora (MainActivity.this), y la clase de la actividad llamada (SaludoActivity.class).
Si quisiramos tan slo mostrar una nueva actividad ya tan slo nos quedara llamar a startActivity() pasndole como parmetro el intent
creado. Pero en nuestro ejemplo queremos tambin pasarle cierta informacin a la actividad llamada, concretamente el nombre que introduzca el
usuario en el cuadro de texto de la pantalla principal. Para hacer esto creamos un objeto Bundle, que puede contener una lista de pares clavevalor con toda la informacin a pasar entre actividades. En nuestro caso slo aadimos un dato de tipo String mediante el
mtodo putString(clave, valor). Como clave para nuestro dato yo he elegido el literal NOMBRE aunque podis utilizar cualquier
otro literal descriptivo. Por su parte, el valor de esta clave lo obtenemos consultando el contenido del cuadro de texto de la actividad principal, lo
que podemos conseguir llamando a su mtodo getText() y convirtiendo este contenido a texto mediante toString() (ms adelante en el
curso veremos por qu es necesaria esta conversin).
Tras esto aadiremos la informacin al intent mediante el mtodo putExtras(). Si necesitramos pasar ms datos entre una actividad y otra
no tendramos ms que repetir estos pasos para todos los parmetros necesarios.
Con esto hemos finalizado ya actividad principal de la aplicacin, por lo que pasaremos ya a la secundaria. Comenzaremos de forma anloga a la
anterior, ampliando el mtodo onCreate() obteniendo las referencias a los objetos que manipularemos, esta vez slo la etiqueta de texto. Tras
esto viene lo ms interesante, debemos recuperar la informacin pasada desde la actividad principal y asignarla como texto de la etiqueta. Para
ello accederemos en primer lugar al intent que ha originado la actividad actual mediante el mtodo getIntent() y recuperaremos su
informacin asociada (objeto Bundle) mediante el mtodo getExtras().
Hecho esto tan slo nos queda construir el texto de la etiqueta mediante su mtodo setText(texto) y recuperando el valor de nuestra clave
almacenada en el objeto Bundle mediante getString(clave).
1
2
3
4
5
6
package net.sgoliver.android.holausuario;
//...
import android.widget.TextView;
public class SaludoActivity extends AppCompatActivity {
7
8
private TextView txtSaludo;
9
10
@Override
11
protected void onCreate(Bundle savedInstanceState) {
12
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_saludo);
13
14
//Localizar los controles
15
txtSaludo = (TextView)findViewById(R.id.TxtSaludo);
16
17
//Recuperamos la informacin pasada en el intent
18
Bundle bundle = this.getIntent().getExtras();
19
//Construimos el mensaje a mostrar
20
txtSaludo.setText("Hola " + bundle.getString("NOMBRE"));
21
}
22
23
//...
24
}
25
26
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 definidas en este fichero. En este caso, Android Studio se debe haber ocupado por nosotros de definir
ambas actividades en el fichero, pero lo revisaremos para as echar un vistazo al contenido.
Si abrimos el fichero AndroidManifest.xml veremos que contiene un elemento principal<application> que debe incluir varios
elementos <activity>, uno por cada actividad incluida en nuestra aplicacin. En este caso, comprobamos como efectivamente Android
Studio ya se ha ocupado de esto por nosotros, aunque este fichero s podramos modificarlo a mano para hacer ajustes si fuera necesario.
1
2
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
3
package="net.sgoliver.android.holausuario" >
4
5
<application
6
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
7
android:label="@string/app_name"
8
android:theme="@style/AppTheme" >
9
<activity
10
android:name=".MainActivity"
11
android:label="@string/app_name" >
<intent-filter>
12
<action android:name="android.intent.action.MAIN" />
13
14
<category android:name="android.intent.category.LAUNCHER" />
15
</intent-filter>
16
</activity>
<activity
17
android:name=".SaludoActivity"
18
android:label="@string/title_activity_saludo" >
19
</activity>
20
</application>
21
22
</manifest>
23
24
Podemos ver como para cada actividad se indica entre otras cosas el nombre de su clase java asociada como valor del atributo android:name,
y su ttulo mediante el atributo android:label, ms adelante veremos qu opciones adicionales podemos especificar. Vemos una vez ms
cmo el ttulo de las actividades se indica como referencia a cadenas de caracteres definidas como recursos, que deben estar incluidas como ya
hemos comentado anteriormente en el fichero /main/res/values/strings.xml
El ltimo elemento que revisaremos de nuestro proyecto, aunque tampoco tendremos que modificarlo por ahora, ser el fichero build.gradle.
Pueden existir varios ficheros llamados as en nuestra estructura de carpetas, a distintos niveles, pero normalmente siempre accederemos al que
est al nivel ms interno, en nuestro caso el que est dentro del mdulo app. Veamos qu contiene:
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
defaultConfig {
applicationId "net.sgoliver.android.holausuario"
minSdkVersion 15
targetSdkVersion 23
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:23.0.0'
}
Gradle es el nuevo sistema de compilacin y construccin que ha adoptado Google para Android Studio. Pero no es un sistema especfico de
Android, sino que puede utilizarse con otros lenguajes/plataformas. Por tanto, lo primero que indicamos en este fichero es que utilizaremos el
plugin para Android mediante la sentencia apply plugin. A continuacin definiremos varias opciones especficas de Android, como las
versiones de la API mnima (minSdkVersion), API objetivo (targetSdkVersion), y API de compilacin (compileSdkVersion) que
utilizaremos en el proyecto, la versin de las build tools (buildToolsVersion) que queremos utilizar (es uno de los componentes que
podemos descargar/actualizar desde el SDK Manager), la versin tanto interna (versionCode) como visible (versionName) de la
aplicacin, o la configuracin de ProGuard si estamos haciendo uso de l (no nos preocupamos por ahora de esto). Durante el curso iremos
viendo con ms detalle todos estos elementos. El ultimo elemento llamado dependencies tambin es importante y nos servir entre otras
cosas para definir las libreras externas que utilizaremos en la aplicacin. Por defecto vemos que se aade la librera de
compatibilidad appcompat-v7 que nos permite utilizar la Action Bar en la mayora de versiones de Android, y todos los fichero .jar que
incluyamos en la carpeta /libs.
Llegados aqu, y si todo ha ido bien, deberamos poder ejecutar el proyecto sin errores y probar nuestra aplicacin en el emulador, pero para ello
tendremos que definir primero uno. Vamos a describir los pasos para hacerlo.
Para poder probar aplicaciones Android en nuestro PC, sin tener que recurrir a un dispositivo fsico, tenemos que definir lo que se denominan
AVD (Android Virtual Device). Para crear un AVD seleccionaremos el men Tools / Android / AVD Manager. Si es la primera vez que accedemos
a esta herramienta veremos la pantalla siguiente:
Pulsando el botn central Create a virtual device accederemos al asistente para crear un AVD. En el primer paso tendremos que seleccionar a la
izquierda qu tipo de dispositivo queremos que simule nuestro AVD (telfono, tablet, reloj, ) y el tamao, resolucin, y densidad de pxeles
de su pantalla. En mi caso seleccionar por ejemplo las caractersticas de un Nexus 5 y pasaremos al siguiente paso pulsando Next.
En la siguiente pantalla seleccionaremos la versin de Android que utilizar el AVD. Aparecern directamente disponibles las que instalamos
desde el SDK Manager al instalar el entorno, aunque tenemos la posibilidad de descargar e instalar nuevas versiones desde esta misma pantalla.
En mi caso utilizar 5.1 Lollipop (API 22) para este primer AVD (podemos crear tantos como queramos para probar nuestras aplicaciones sobre
distintas condiciones).
En el siguiente paso del asistente podremos configurar algunas caractersticas ms del AVD, como por ejemplo la cantidad de memoria que
tendr disponible, si simular tener cmara frontal y/o trasera, teclado fsico, Recomiendo pulsar el botn Show Advanced Settings para ver
todas las opciones disponibles. Si quieres puedes ajustar cualquiera de estos parmetros, pero por el momento os recomiendo dejar todas las
opciones por defecto. Tan slo nos aseguraremos de tener activada la opcin Use Host GPU con la que normalmente conseguiremos un mayor
rendimiento del emulador.
Tras pulsar el botn Finish tendremos ya configurado nuestro AVD, por lo que podremos comenzar a probar nuestras aplicaciones sobre l.
Para ello, tras cerrar el AVD Manager, pulsaremos simplemente el men Run / Run app (o la tecla rpida Mays+F10). Android Studio nos
preguntar en qu dispositivo queremos ejecutar la aplicacin y nos mostrar dos listas. La primera de ellas (running devices) con los
dispositivos que haya en ese momento en funcionamiento (por ejemplo si ya tenamos un emulador funcionando) y en segundo lugar una lista
desplegable con el resto de AVDs configurados en nuestro entorno. Podremos seleccionar cualquiera de los emuladores disponibles en cualquiera
de las dos listas. Lo normal ser mantener un emulador siempre abierto y seleccionarlo de la primera lista cada vez que ejecutemos la aplicacin.
Elegir para este ejemplo el AVD que acabamos de crear y configurar. Es posible que la primera ejecucin se demore unos minutos, todo
depender de las caractersticas de vuestro PC, as que paciencia.
Si todo va bien, tras una pequea (o no tan pequea) espera aparecer el emulador de Android y se iniciar automticamente nuestra aplicacin
(si se inicia el emulador pero no se ejecuta automticamente la aplicacin podemos volver a ejecutarla desde Android Studio, mediante el men
Run, sin cerrar el emulador ya abierto).
Podemos probar a escribir un nombre y pulsar el botn Aceptar para comprobar si el funcionamiento es el correcto.
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.
Comparte esta entrada:
Facebook22
Correo electrnico
Relacionado
Categoras: Programacin, AndroidEtiquetas: ejemplo, aplicacin, primera, sencillo, conceptos, bsicos, curso android, Android Studio
Comentarios
1.
Carlos dice
20/01/2015 a las 2:12
2.
Kazama dice
20/01/2015 a las 5:23
Excelente tutorial, hasta aca todo bien conmigo, solo q tuve q agregar una libreria:
import android.view.View;
en el MainActivity
y me corrio excelente, otro comentario es que tuve problemas con HAXM, pero ya lo resolvi y tambien con correrla
desde mi movil (Samsung GT-S6010) conectado a USB por modo depuracion, pero al final logre solucionar eso
tambien.
seguire por aca leyendo y dejando mis comentarios, de antemano. Mil gracias!!!
3.
Francisco dice
24/01/2015 a las 5:07
Hola muy buen tutorial esta explicado exelentemente
Tengo una duda no puedo ejecutar el emulador, no puedo instalarlo no es compatible me dice. Tengo un procesador
amd, se podr instalar?
4.
Joel dice
24/01/2015 a las 17:18
Excelente tutorial, he realizado mi primer ejemplo en Android gracias a este magnifico tutorial, detallado
magnifcamente.
Tuve ciertos inconvenientes que los resolvi con mucha perseverancia y lectura, y que me ayudo a conocer mejor el
lenguaje.
Uno de los temas que mas tuve problemas fue con la constante R que el sistema no la veia.
Lo recomiendo, muy bueno!
5.
javier dice
27/01/2015 a las 1:50
A mi me est pasando que siguiendo el tutorial no consigo que la R.id me aparezca en negro, todo el rato la R la
tengo en rojo. y pone el siguiente texto situndome encima:
Cannot resolve symbol R.
Podrais indicarme cmo solucionarlo? No s qu estoy haciendo mal
Mil gracias de antemano.
Saludos.
6.
Oscar dice
29/01/2015 a las 22:37
Hola, no entiendo que siginifca el parametro v, en public void onClick(View v)
7.
Rodrigo dice
31/01/2015 a las 19:43
Venas explicando muy bien hasta que derrapaste como un campen en:
Por su parte, si revisamos ahora el cdigo de la clase java SaludoActivity veremos que es anlogo a la actividad
principal.
Siendo nuevo hasta ah entend perfectamente, de ah te olvidaste de explicar bien donde copiar cada uno de los
cdigos que vas dictando. Al principio lo explicabas muy bien despus te fuiste al carajo
8.
admin dice
31/01/2015 a las 22:09
Me alegra recibir crticas tan constructivas. Al final de cada artculo tenis el enlace (GitHub) al cdigo completo del
ejemplo descrito, que debera usarse siempre como referencia complementaria al contenido del curso.
9.
Hector dice
02/02/2015 a las 0:01
Buenas noches,
Me pueden ayudar? me est dando error al ejecutar que dice:
error: package view does not exist en el mainactivity
10.
Hector dice
11.
Lupe dice
12.
alejandro dice
13.
Alex dice
.
android:onClick="
Y despues en el java se crea un public void que contiene todas las acciones a realizar por el evento. Cual forma es
la mejor?
14.
Jesus dice
15.
Ulises dice
16.
Jimmy dice
17.
18.
19.
julio dice
20.
julio dice
21.
Tengo un pequeo problema al ejecutar el apk en el dispositivo, ya que me genera el siguiente error de anlisis: Se
ha producido un problema al analizar el paquete. Ya trate de modificar algunos parmetros y verifique que estuviese
instalado el Android 2.2 (API 8) pero me sigue generando el mismo error. Pueden por favor ayudarme con esto, se
los agradezco de antemano.
Saludos
22.
Ulises dice
23.
Miguel dice
24.
Ahuitzol dice
25.
JC dice
26.
27.
Dante dice
28.
29.
30.
Alexander dice
31.
Alejo dice
32.
33.
marina dice
34.
Miguel dice
35.
JMRD dice
36.
37.
nickenino dice
38.
christian dice
[IMG]http://i57.tinypic.com/25r191j.jpg[/IMG]
39.
Rulo dice
40.
Susana dice
41.
42.
Buen manual para iniciar en Android, una pregunta he construido una aplicacin que utiliza la camara, todo la foto y
guarda todo bien, pero necesito que le agregue un marco a la foto, no se por donde tirar, o que mtodo utilizar,
propiedad o clase, espero me eches un cable, gracias,
43.
Claudio dice
44.