Inicio Android Desarrollando una aplicación Android sencilla (Android Studio)

Desarrollando una aplicación Android sencilla (Android Studio)

por sgoliver

Actualizado: Abril 2020

El ritmo de actualizaciones de Android Studio es bastante alto, por lo que algunos detalles de este artículo pueden no ajustarse exactamente a la última versión de la aplicación. Este artículo se encuentra actualizado para la versión de Android Studio 3.6

Después de instalar nuestro entorno de desarrollo para Android y comentar la estructura básica de un proyecto y los diferentes componentes software que podemos utilizar ya es hora de empezar a escribir algo de código. Y como siempre lo mejor es empezar por escribir una aplicación sencilla.

En un principio me planteé analizar en este capítulo el clásico Hola Mundo pero más tarde me pareció que se iban a quedar algunas cosas básicas en el tintero. Así que he versionado a mi manera el Hola Mundo transformándolo en algo así como un Hola Usuario, que es igual de sencilla pero añade un par de cosas interesantes de contar.

La aplicación 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 inútil, pero aprenderemos muchos conceptos básicos, que para empezar no está mal.

Por dibujarlo para entender mejor lo que queremos conseguir, sería algo tan sencillo como lo siguiente:

demo-app

Vamos a partir del proyecto de ejemplo que creamos en un apartado anterior, al que casualmente llamamos Hola Usuario.

Como ya vimos, Android Studio había creado por nosotros la estructura de carpetas del proyecto y todos los ficheros necesarios de un Hola Mundo básico, es decir, una sola pantalla donde se muestra únicamente un mensaje fijo.

Lo primero que vamos a hacer es diseñar nuestra pantalla principal modificando la que Android Studio nos ha creado por defecto. Aunque ya lo habíamos comentado de pasada, recordemos dónde y cómo se define cada pantalla de la aplicación. En Android, el diseño y la lógica de una pantalla están separados en dos ficheros distintos. Por un lado, en el fichero  /src/main/res/layout/activity_main.xml tendremos el diseño puramente visual de la pantalla definido como fichero XML y por otro lado, en el fichero  /src/main/java/mi.paquete.java/MainActivity.kt, encontraremos el código kotlin que determina la lógica de la pantalla.

Vamos a modificar en primer lugar el aspecto de la ventana (activity) principal de la aplicación añadiendo los controles (views) que vemos en el esquema mostrado al principio del apartado. Para ello, vamos a sustituir el contenido completo del fichero activity_main.xml por el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<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"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/aceptar" />

</LinearLayout>

Recuerda que si no ves el código XML al abrir el fichero del layout, puedes alternar entre el editor visual y el de código con los botones de la esquina superior derecha de la ventana, como comentamos en el artículo anterior sobre la estructura de un proyecto de Android Studio.

Al pegar este código en el fichero de layout aparecerán 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 componentes de tipo layout son elementos no visibles que determinan cómo se van a distribuir en el espacio los controles que incluyamos en su interior. Los programadores java, y más concretamente de Swing (aquellos que aún recuerden qué es eso), conocerán este concepto perfectamente. En este caso, un LinearLayout distribuirá los controles simplemente uno tras otro y en la orientación 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 botón (Button). En todos ellos hemos establecido las siguientes propiedades:

  • android:id. ID del control, con el que podremos identificarlo más tarde en nuestro código. Vemos que el identificador lo escribimos precedido de “@+id/”. Esto tendrá como efecto que al compilarse el proyecto se genere automáticamente 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 más tarde acceder al él desde nuestro código kotlin 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 ajustarán 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.

Además de estas propiedades comunes a casi todos los controles que utilizaremos, en el cuadro de texto hemos establecido también la propiedad android:inputType, que indica qué tipo de contenido va a albergar el control, en este caso será texto general (valor «text»), aunque podría haber sido una contraseña (valor «textPassword»), un teléfono («phone»), una fecha («date»), ….

Por último, en la etiqueta y el botón 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 habría sido indicar directamente el texto como valor de la propiedad, por ejemplo en la etiqueta de esta forma:

<TextView android:id="@+id/lblNombre"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Escribe tu nombre:" />

Y la segunda alternativa, la opción más recomendada y la que utilizo en este ejemplo, consistiría 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:”.

<resources>
    ...
    <string name="nombre">Escribe tu nombre:</string>
    ...
</resources>

Y posteriormente indicar el identificador de dicha cadena como valor de la propiedad android:text, siempre precedido del prefijo “@string/”, de la siguiente forma:

<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 aplicación, lo que nos podría facilitar por ejemplo la traducción de la aplicación 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 deberían desaparecer los dos errores marcados en rojo que nos aparecieron antes en la ventana activity_main.xml.

Con esto ya tenemos definida la presentación visual de nuestra ventana principal de la aplicación, veamos ahora la lógica de la misma. Como ya hemos comentado, la lógica de la aplicación se definirá en ficheros de código kotlin independientes. Para la pantalla principal ya tenemos creado un fichero por defecto llamado MainActivity.kt. Empecemos por comentar su código por defecto:

package android.sgoliver.net.holausuario

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Como ya vimos en un apartado anterior, las diferentes pantallas de una aplicación Android se definen mediante objetos de tipo Activity. Por tanto, lo primero que encontramos en nuestro fichero kotlin es la definición de una nueva clase MainActivity que extiende en este caso de un tipo especial de Activity llamado AppCompatActivity, que soporta entre otras cosas la utilización de la Action Bar en nuestras aplicaciones (la action bar es la barra de título y menú superior que se utiliza en la mayoría de aplicaciones Android). El único método que modificaremos por ahora en esta clase será el método onCreate(), llamado cuando se crea por primera vez la actividad. En este método lo único que encontramos en principio, además de la llamada a su implementación en la clase padre, es la llamada al método setContentView(R.layout.activity_main). Con esta llamada estaremos indicando a Android que debe establecer como interfaz gráfica de esta actividad la definida en el recurso R.layout.activity_main, que no es más que la que hemos especificado en el fichero /src/main/res/layout/activity_main.xml. Una vez más vemos la utilidad de las diferentes constantes de recursos creadas automáticamente en la clase R al compilar el proyecto.

Antes de modificar el código de nuestra actividad principal, vamos a crear una nueva actividad para la segunda pantalla de la aplicación análoga a ésta primera, a la que llamaremos SaludoActivity.

Para ello, accederemos al menú File y seleccionaremos la opción de menú New/Activity/Empty Activity.

En el cuadro de diálogo que nos aparece indicaremos el nombre de la actividad, en nuestro caso «SaludoActivity», el nombre de su layout XML asociado (Android Studio creará al mismo tiempo tanto el layout XML como la clase kotlin), que llamaremos «activity_saludo», el nombre del paquete java de la actividad que podemos dejar con su valor por defecto, y el lenguaje a utilizar, siempre Kotlin.

Pulsaremos Finish y Android Studio creará los nuevos ficheros SaludoActivity.kt y activity_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 añadiendo esta vez tan sólo un LinearLayout como contenedor y una etiqueta (TextView) para mostrar el mensaje personalizado al usuario. Para esta segunda pantalla el código que incluiríamos sería el siguiente:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/lytContenedorSaludo"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView android:id="@+id/txtSaludo"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="" />

</LinearLayout>

Por su parte, si revisamos ahora el código de la clase SaludoActivity veremos que es análogo a la actividad principal:

package android.sgoliver.net.holausuario

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class SaludoActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_saludo)
    }
}

Sigamos. Por ahora, el código 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 lógica de la aplicación.

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 sólo el cuadro de texto y el botón. Para ello definiremos ambas referencias como propiedades de la clase y para obtenerlas utilizaremos el método findViewById() indicando el ID de cada control, definidos como siempre en la clase R. Todo esto lo haremos dentro del método onCreate() de la clase MainActivity, justo a continuación de la llamada a setContentView() que ya comentamos.

package android.sgoliver.net.holausuario

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText

class MainActivity : AppCompatActivity() {

    private lateinit var txtNombre : EditText
    private lateinit var btnAceptar : Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //Obtenemos una referencia a los controles de la interfaz
        txtNombre = findViewById(R.id.txtNombre)
        btnAceptar = findViewById(R.id.btnAceptar)
    }
}

Como vemos, hemos añadido también varios import adicionales (los de las clases Button y EditText) para tener acceso a todas las clases utilizadas.

Una vez tenemos acceso a los diferentes controles, ya sólo nos queda implementar las acciones a realizar cuando pulsemos el botón. Para ello, continuando el código anterior, y siempre dentro del método onCreate(), implementaremos el evento onClick de dicho botón. Este botón tendrá que ocuparse de abrir la actividad SaludoActivity pasándole toda la información necesaria. Veamos cómo:

package android.sgoliver.net.holausuario

import android.content.Intent
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {

    private lateinit var txtNombre : EditText
    private lateinit var btnAceptar : Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //Obtenemos una referencia a los controles de la interfaz
        txtNombre = findViewById(R.id.txtNombre)
        btnAceptar = findViewById(R.id.btnAceptar)

        btnAceptar.setOnClickListener {
            //Creamos el Intent
            val intent = Intent(this@MainActivity, SaludoActivity::class.java)

            //Añadimos al intent la información a pasar entre actividades
            intent.putExtra("NOMBRE", txtNombre.text.toString())

            //Iniciamos la nueva actividad
            startActivity(intent)
        }
    }
}

Como ya indicamos en el apartado anterior, la comunicación 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 aplicación, para lo que pasaremos a su constructor una referencia a la propia actividad llamadora (this@MainActivity), y la clase de la actividad llamada (SaludoActivity::class.java).

Si quisiéramos tan sólo mostrar la nueva actividad ya tan sólo nos quedaría llamar a startActivity() pasándole como parámetro el intent creado. Pero en nuestro ejemplo queremos también pasarle cierta información a la actividad llamada, concretamente el nombre que introduzca el usuario en el cuadro de texto de la pantalla principal. Para hacer esto utilizaremos el método putExtra() de la clase Intent, con el que podremos añadir al intent la información que queremos pasar entre actividades. El método putExtra() recibe como parámetros una clave y un valor. En nuestro caso sólo tendremos que pasar el nombre del usuario, y como clave yo he elegido el literal «NOMBRE», aunque podéis utilizar cualquier otro literal descriptivo. Por su parte, el valor para esta clave lo obtenemos consultando el contenido del cuadro de texto de la actividad principal, txtNombre, lo que podemos conseguir llamando a su propiedad text y convirtiendo este contenido a texto mediante toString() (más adelante en el curso veremos por qué es necesaria esta conversión).

Si necesitáramos pasar más datos entre una actividad y otra no tendríamos más que repetir la llamada a putExtra() para todos los datos necesarios.

Con esto hemos finalizado ya la actividad principal de la aplicación, por lo que pasaremos ya a la secundaria. Comenzaremos de forma análoga a la anterior, ampliando el método onCreate() obteniendo las referencias a los objetos que manipularemos, esta vez sólo la etiqueta de texto. Tras esto viene lo más interesante, debemos recuperar la información 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 la propiedad intent y recuperaremos su información mediante el método getStringExtra() (ya que en este caso el dato pasado era de tipo String).

Hecho esto tan sólo nos queda asignar el texto de la etiqueta mediante su propiedad text, concatenando el texto de saludo que deseemos con el valor del nombre del usuario recuperado.

package android.sgoliver.net.holausuario

import android.os.Bundle
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity

class SaludoActivity : AppCompatActivity() {

    private lateinit var txtSaludo : TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_saludo)

        //Obtenemos una referencia a los controles de la interfaz
        txtSaludo = findViewById(R.id.txtSaludo)

        //Recuperamos la información pasada en el intent
        val saludo = intent.getStringExtra("NOMBRE")

        //Construimos el mensaje a mostrar
        txtSaludo.text = "Hola $saludo"
    }
}

Con esto hemos concluido la lógica de las dos pantallas de nuestra aplicación y tan sólo nos queda un paso importante para finalizar nuestro desarrollo. Como ya indicamos en un apartado anterior, toda aplicación Android utiliza un fichero especial en formato XML llamado AndroidManifest.xml para definir, entre otras cosas, los diferentes elementos que la componen. Por tanto, todas las actividades de nuestra aplicación 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 aplicación. En este caso, comprobamos como efectivamente Android Studio ya se ha ocupado de esto por nosotros, aunque este fichero sí podríamos modificarlo a mano para hacer ajustes si fuera necesario.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="android.sgoliver.net.holausuario">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".SaludoActivity"></activity>
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Podemos ver como para cada actividad se indica entre otras cosas el nombre de su clase kotlin asociada como valor del atributo android:name, más adelante veremos qué opciones adicionales podemos especificar.

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 más interno, en nuestro caso el que está dentro del módulo «app». Veamos qué contiene:

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'

android {
    compileSdkVersion 29
    buildToolsVersion "29.0.3"

    defaultConfig {
        applicationId "android.sgoliver.net.holausuario"
        minSdkVersion 26
        targetSdkVersion 29
        versionCode 1
        versionName "1.0"

        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation 'androidx.appcompat:appcompat:1.0.2'
    implementation 'androidx.core:core-ktx:1.0.2'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

Gradle es el sistema de compilación y construcción que ha adoptado Google para Android. Pero no es un sistema específico de Android, sino que puede utilizarse con otros lenguajes/plataformas. Por tanto, lo primero que indicamos en este fichero es que utilizaremos varios plugins para Android mediante la sentencia apply plugin. A continuación definiremos entre otras cosas varias opciones específicas de Android, como las versiones de la API mínima (minSdkVersion), la API objetivo (targetSdkVersion), y API de compilación (compileSdkVersion) que utilizaremos en el proyecto, la versión de las build tools (buildToolsVersion) que queremos utilizar (recordemos que es uno de los componentes que descargamos desde el SDK Manager cuando instalamos el entorno de desarrollo), la versión tanto interna (versionCode) como visible (versionName) de la aplicación, o la configuración de ProGuard si estamos haciendo uso de él (no nos preocuparemos por ahora de esto). El ultimo elemento llamado dependencies también es importante y nos servirá entre otras cosas para definir las librerías externas que utilizará nuestra aplicación. Puedes ver que Android Studio ya añade por defecto varias dependencias a los nuevos proyectos, poco a poco iremos conociéndolas, nos conformamos por ahora con saber que se definen y se podrían modificar en este lugar.

Llegados aquí, y si todo ha ido bien, deberíamos poder ejecutar ya el proyecto sin errores y probar nuestra aplicación en el emulador. Vamos a hablar un poco de este tema.

Para poder probar aplicaciones Android en nuestro PC, sin tener que recurrir a un dispositivo físico (aunque por supuesto también es posible), tenemos que definir lo que se denomina un AVD o Android Virtual Device. Si seguiste el artículo de instalación del entorno de desarrollo ya deberías tener un AVD creado y disponible para probar (si no es así no te preocupes, en breve veremos como crear uno nuevo). Lo podemos comprobar accediendo al menú Tools/AVD Manager.

La herramienta AVD Manager nos permite crear y gestionar dispositivos virtuales de Android (AVD), que como hemos comentado serán nuestro sustituto de un dispositivo físico a la hora de probar y depurar en el PC nuestras aplicaciones. En la ventana inicial del AVD Manager podemos ver los AVD que ya tenemos creados y disponibles para utilizar. Como puedes ver en la captura anterior, en mi caso particular tengo disponible un AVD llamado «Nexus 5X API 29 x86». Éste es el AVD que Android Studio ha creado por nosotros durante el proceso de instalación. En la misma lista podemos comprobar las características principales de este AVD, como las dimensiones y la resolución de la pantalla, o el nivel de API Android que utiliza (la 29 en mi caso, que equivale a Android 10).

Una vez comprobado que tenemos un AVD disponible, podemos cerrar ya el AVD Manager y disponernos a ejecutar nuestra aplicación en el emulador de Android sobre este AVD. Para ello, podemos dirigirnos a la barra de herramientas superior, desde donde podemos seleccionar el AVD que queremos utilizar para ejecutar la aplicación (podemos tener varios AVD creados, en cuyo caso tendremos que seleccionar uno de ellos en la lista desplegable) y pulsar el botón verde justo a su derecha para iniciar la ejecución (o bien el menú Run/Run ‘app’).

Si todo va bien, debería abrirse el emulador de Android, e iniciarse nuestra aplicación. Si es la primera vez que inicias el emulador y/o un AVD determinado es posible que la primera ejecución se demore algún tiempo. Ejecuciones posteriores deberían ser más rápidas.

En la imagen anterior podemos ver nuestra primera aplicación ya iniciada en el emulador de Android. Podemos probar a escribir un nombre en el cuadro de texto y pulsar el botón “ACEPTAR” para comprobar si el funcionamiento es el esperado.

Ya hemos desarrollado y ejecutado nuestra primera aplicación en el emulador de Android.

Si quisiéramos crear otro AVD, por ejemplo para probar nuestra aplicación sobre otra resolución de pantalla, o sobre otra versión de Android, podemos volver de nuevo la herramienta AVD Manager, accediendo al menú Tools/AVD Manager.

Para crear un nuevo AVD pulsaremos el botón «Create Virtual Device…» situado en la esquina inferior izquierda del AVD Manager. Esto iniciará el asistente de creación de un AVD. En la primera pantalla tendremos que seleccionar el tipo de dispositivo que queremos crear: teléfono, tablet, smartwatch (Wear OS), Android TV, o Android Auto. Una vez seleccionado el tipo de dispositivo, podemos seleccionar las características concretas del dispositivo (tamaño, resolución, y densidad de píxeles de su pantalla, memoria, cámaras, …). Para ellos podremos elegir entre una lista predefinida de modelos reales de dispositivo, algunos modelos genéricos, o bien definir nuestro propio dispositivo a medida pulsando el botón «New Hardware Profile».

En mi caso seleccionaré el modelo «Pixel 3a». Pulsaremos el botón Next para continuar con el proceso. En la siguiente pantalla seleccionaremos la versión de Android que utilizará el AVD. Aparecerán directamente disponibles las que instalamos desde el SDK Manager al preparar el entorno de desarrollo, aunque tenemos la posibilidad de descargar e instalar nuevas versiones desde esta misma pantalla. En mi caso particular utilizaré la imagen x86 de Android 10 (API 29).

En el siguiente paso del asistente podremos configurar algunas características más del AVD, como por ejemplo la cantidad de memoria que tendrá disponible, si simulará tener cámara frontal y/o trasera, … Recomiendo pulsar el botón «Show Advanced Settings» de la parte inferior para revisar todas las opciones disponibles. Si quieres puedes ajustar cualquiera de estos parámetros, pero por el momento os recomiendo dejar todas las opciones por defecto.

Tras pulsar el botón Finish tendremos ya configurado nuestro nuevo AVD, por lo que podremos comenzar a probar nuestras aplicaciones sobre él.

Podemos seleccionar nuestro nuevo AVD en la lista desplegable de la barra de herramientas superior, igual que hicimos en la primera ejecución, y volvemos a pulsar el botón o menú de ejecutar, igual que hicimos en la primera ocasión. Si todo va bien nuestra aplicación se iniciará en el nuevo AVD que hemos creado.

Y con esto terminamos por ahora. Espero que esta aplicación de ejemplo os sea de ayuda para aprender temas básicos en el desarrollo para Android, como por ejemplo la definición de la interfaz gráfica, el código java necesario para acceder y manipular los elementos de dicha interfaz, y la forma de comunicar diferentes actividades de Android. En los apartados siguientes del curso veremos algunos de estos temas de forma mucho más detallada.

También te puede interesar

73 comentarios

Desarrollando una aplicación Android sencilla (Eclipse) | sgoliver.net blog 16/01/2015 - 20:30

[…] Android Studio como nueva herramienta oficial de desarrollo para Android. Te aconsejo que leas el nuevo capítulo dedicado a la creación de una aplicación sencilla en Android […]

Responder
Interfaz de usuario en Android: Layouts | sgoliver.net blog 17/01/2015 - 20:33

[…] el artículo anterior del curso, donde desarrollamos una sencilla aplicación Android desde cero, ya hicimos algunos […]

Responder
Carlos 20/01/2015 - 2:12

Hola una consulta
en el metodo SaludoActivity de la clase SaludoActivity.java cuando declaro lo siguiente:

private TextView txtSaludo;

me muestra en color violeta esa variable y con el msj «Field can be converted to a local variable»
y luego en el mismo metodo y en la siguiente linea:

txtSaludo = (TextView)findViewById(R.id.TxtSaludo):

me marca la TxtSaludo en rojo con el msj «cannot resolve the symbol ‘TxtSaludo’ »
como lo soluciono y porque paso eso?

Responder
Kazama 20/01/2015 - 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!!!

Responder
Francisco 24/01/2015 - 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?

Responder
Joel 24/01/2015 - 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!

Responder
javier 27/01/2015 - 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 situándome encima:
Cannot resolve symbol ‘R’.

Podríais indicarme cómo solucionarlo? No sé qué estoy haciendo mal…

Mil gracias de antemano.

Saludos.

Responder
Oscar 29/01/2015 - 22:37

Hola, no entiendo que siginifca el parametro v, en public void onClick(View v)

Responder
Rodrigo 31/01/2015 - 19:43

Venías explicando muy bien hasta que derrapaste como un campeón en:

Por su parte, si revisamos ahora el código de la clase java SaludoActivity veremos que es análogo a la actividad principal.

Siendo nuevo hasta ahí entendí perfectamente, de ahí te olvidaste de explicar bien donde copiar cada uno de los códigos que vas dictando. Al principio lo explicabas muy bien después te fuiste al carajo

Responder
admin 31/01/2015 - 22:09

Me alegra recibir críticas tan constructivas. Al final de cada artículo tenéis el enlace (GitHub) al código completo del ejemplo descrito, que debería usarse siempre como referencia complementaria al contenido del curso.

Responder
Hector 02/02/2015 - 0:01

Buenas noches,

¿Me pueden ayudar? me está dando error al ejecutar que dice:

error: package view does not exist en el mainactivity

Responder
Hector 02/02/2015 - 0:17

Hola de nuevo,

Para solucionarlo he depurado y pulsado en importar la clase, por favor, ¿me pueden explicar por qué se solucionó así?

Muchas gracias.

Responder
Lupe 11/02/2015 - 18:02

Buenísimo gracias

Responder
alejandro 22/02/2015 - 18:01

Excelente material!, estaba esperando que empieces a utilizar android studio en tus tutoriales, espero que sigas sacando mas ya que me son de mucha ayuda, gracias por tu trabajo!

Responder
Alex 23/02/2015 - 2:36

Hola, una pequeña pregunta. Tu blog lo estoy usando solo como referencia y refuerzo de un tuto que conseguí, pero en el otro tuto se crea el evento onClick en el xml de la pantalla dentro de Button… Algo asi:
<Button….
….
….
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?

Responder
Jesus 23/02/2015 - 12:24

Excelente. Muchas gracias.

Responder
Ulises 04/03/2015 - 19:03

Carlos de casualidad ya modificaste el archivo activity_saludo.xml, ya que posiblemente sea por eso.

Responder
Jimmy 14/03/2015 - 6:22

Genial!! Por fin algo dirente al Hola Mundo. Saludos.

Responder
Omar Espinel 18/03/2015 - 23:32

Falta adicionar

import android.view.View;

Responder
Carlos López 19/03/2015 - 4:10

emulator: ERROR: x86 emulation currently requires hardware acceleration!
Please ensure Intel HAXM is properly installed and usable.
CPU acceleration status: HAX kernel module is not installed!

Responder
julio 19/03/2015 - 19:25

en ningun momento dijiste de que forma se solucionaba el problema del android:text=»@string/nombre» /> asi como tambien el android:text=»@string/aceptar» />

si me puedes ayudar por favor

Responder
julio 19/03/2015 - 19:25

por cierto no lo dije pero muy buen aporte!!!

Responder
Carlos López 25/03/2015 - 20:59

Tengo un pequeño problema al ejecutar el apk en el dispositivo, ya que me genera el siguiente error de análisis: Se ha producido un problema al analizar el paquete. Ya trate de modificar algunos parámetros 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…

Responder
Ulises 30/03/2015 - 8:01

Hola, en mi proyecto no existe la clase R, por lo que todas las referencias a ella me las marca en error (color rojo) seguí todo bien, que ocurre?

Responder
Miguel 30/03/2015 - 14:06

Para los que tienen el siguiente error…

emulator: ERROR: x86 emulation currently requires hardware acceleration!
Please ensure Intel HAXM is properly installed and usable.
CPU acceleration status: HAX kernel module is not installed!

…tuve el mismo problema. Y leyendo en otros sitios, por fin encontré una solución.
Descargar e instalar Genymotion, compatible con Andorid Studio. Cuando te lo instalas, te dice que si quieres también VirtualBox de Oracle, el cual también tenéis que aceptar, que es el q se encarga de emular el dispositivo.
Una vez instalado, os vais a Andorid Studio / File / Setting / Plugins / Browse Repositories / Genymotion. Y se os creará un icono al lado del de SDK Manager.

Con Genymotion tenéis que crearos una cuenta (es gratuita). Este programa se encarga de descargar el dispositivo que queremos emular. Y el VirtualBox, el encargado de emularlo.

En el propio propio Geny, dais a add, y seleccionáis el dispositivo y lo descargáis.

Un a vez hecho eso, en Android Studio, dais al icono de Geny y seleccionáis el dispositivo y «Start».

Y ya está, Run app y funciona perfectamente.

Responder
Ahuitzol 14/04/2015 - 23:15

Excelente tutorial, sencillo de seguir y entender. Muchas gracias!!!

Responder
JC 18/04/2015 - 0:56

Hola Julio, para solucionar lo de @string/nombre y @string/aceptar solo agrega en /src/main/res/values/strings.xml :

Escribe tu nombre:
Aceptar:

Saludos

Responder
LUIS EDUARDO RAMIREZ 18/04/2015 - 5:35

Les felicito, de verdad gracias por tomarse el tiempo y dedicacion de crear tutoriales como este y compartir el conocimiento que para muchos de los lectores es de importantisima relevancia, pd: me concentro mas cuando leo que al ver videos.

Responder
Dante 05/05/2015 - 22:15

Excelente tutorial al principio creí que no lograría hacerlo pero creo que todo esta muy bien explicado y lo logre gracias por tus conocimientos continuare hasta conseguir apps mas complejas y útiles.

Responder
David Julian Castaño 27/05/2015 - 18:49

Excelente tutorial, voy bien con todo, aunque he tenido tropiezos, he llegado hasta aqui y seguire.. Mil gracias.

Responder
juan c monte 30/05/2015 - 4:58

He aprendido a desarrollar html, javascript, php y algo de java, que estoy estudiando. Este es mi primer acercamiento al desarrollo de app para android y se que será un largo camino.
Gracias por compartir esto que sabés hacer.
A los cincuenta años me gustaría acercarme a tu nivel de conocimientos, para así también en algún momento poder compartir esto que es nuestra pasión: aprender y crear.
Si te sirve como empuje, gracias por el tiempo dedicado. A muchos nos sirve reálmente,

Responder
Alexander 30/05/2015 - 15:55

Muchas gracias por publicar esta interesante guía, la verdad que me ha llamado mucho la atención este entorno de programación, voy a intentar entrar en este mundo de la creación de apps para Android.

Saludos y muchos éxitos para la web :)

Responder
Alejo 22/06/2015 - 15:15

¿es normal que se demore tanto(!!) el simulador?

Responder
Miguel Zubieta 29/06/2015 - 8:24

Muy útil el curso. Mis felicitaciones. Hasta ahora me fue bien pero con bastante trabajo. Sería muy bueno que respondas a algunas dudas y problemas que muchos tropezamos por igual. Gracias.

Responder
marina 16/07/2015 - 22:40

Hola!! LA verdad te la rifaste con el tuto, muy bueno, GRACIAS!! me ha servido para a cercarme a la programación de apps.

Responder
Miguel 26/07/2015 - 3:35

Muy buen tutorial. Te engancha y hace que le hechemos mas ganas a esto!
Lo único que faltaria es una lista de ERRORES COMUNES resueltos, como aquellos por los que preguntan los usuarios en los comentarios.
Saludos!

Responder
JMRD 13/08/2015 - 10:32

El curso está genial por el momento.
Pero quería comentarte que no hay enlace de un capítulo al siguiente, que es una chorrada, retrocedo al inicio y continúo, pero estaía bien.

También, aunque en el código final está corregido, en el curso sigue faltando el import del View.

Gracias por el curso!

Responder
Jhon Novoa 25/08/2015 - 18:58

Para los que quieran un simulador mas dinamico pueden usar bluestacks para instalar y probar sus aplicaciones.

Responder
nickenino 27/08/2015 - 0:41

Buen tutorial. Muy claro. Gracias.

Responder
christian 05/09/2015 - 16:40

Por que cuando compilo y quiero ver como se ejecuta mi avance y me sale este error:

[IMG]http://i57.tinypic.com/25r191j.jpg[/IMG]

Responder
Rulo 15/09/2015 - 18:26

A mi también me apareció el siguiente error:

emulator: ERROR: x86 emulation currently requires hardware acceleration!
Please ensure Intel HAXM is properly installed and usable.
CPU acceleration status: HAX kernel module is not installed!

Y en mi caso lo solucione habilitando la opción de Tecnoligía de virtualización desde la bios ya que en mi equipo estaba des habilitado (Windows 7) además de instalar manualmente el programa intelhaxm-android.exe (Que es el que se indica en el blog debemos instalar, pero al hacerlo desde el SDK Manager supuestamente si me lo instala dado que no manda error, pero no funciona, una ves que se descarga desde el sdk manager dicho programa debe encontrarse en la siguiente ruta:

dir instalación SDK android\extras\intel\Hardware_Accelerated_Execution_Manager\intelhaxm-android.exe

Responder
Susana 26/09/2015 - 11:37

Lo recomiendo es sencillo y bien explicado.

Responder
Juan Fuentes 11/11/2015 - 8:40

Empecé a visitar esta web hace un par de años para adquirir conocimientos Android, 2 años después veo que está todo actualizado con información sobre Android Studio, nuevos componentes, etc..
Muchas gracias!! Y muy buen trabajo!!

Responder
Carlos Paredes 14/11/2015 - 15:56

Buen manual para iniciar en Android, una pregunta he construido una aplicación 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 método utilizar, propiedad o clase, espero me eches un cable, gracias,

Responder
Claudio 17/11/2015 - 20:01

Hola que tal

Muy buen tutorial, muchas gracias por tu tiempo.}

Al ejecutar la app no sale el cuadro de texto para introducir el nombre, que puede ser.

Muchas Gracias

Responder
Francisco Alvarez 04/12/2015 - 23:20

Exelente Tutorial!!! de verdad muy bien explicado!!!

tengo un pequeno error y no se donde pueda estar, al probar el «hola usuario» en el AVD no me aparece el mensaje en el 2do activity, y revisando en y revisando en la pestana Android Monitor de AS me aparece este error

E/Surface: getSlotFromBufferLocked: unknown buffer: 0xabe71490

no se que hacer y quisiera corregir esto antes de continuar

Responder
DavidM 23/03/2016 - 0:53

Hola que tal tengo un problema en estas lineas de codigo, no me termina de compilar.

@Override
public void onClick(View v) {
//Creamos el Intent
Intent intent =
new Intent(MainActivity.this, SaludoActivity.class);

//Creamos la información a pasar entre actividades
Bundle b = new Bundle();
b.putString(«NOMBRE», txtNombre.getText().toString());

//Añadimos la información al intent
intent.putExtras(b);

//Iniciamos la nueva actividad
startActivity(intent);

El problema esta al declarar el Intent, si alguien puede ayudarme se lo agradeceria mucho.

Responder
pau 23/05/2016 - 22:45

Fantástico tutorial, por fin algo en español con la claridad y el nivel adecuado para arrancar en el desarrollo de apps android.

Después del vía crucis de pasearme por infinidad de paginas web, ver vídeos en youtube, intentar seguir algún curso de los que publica google en Udacity, etc, etc.

Por fin encontré tu web con tu curso en español con el nivel adecuado, actualizado a las ultimas versiones de Android Studio ( no more eclipse, please) y todo explicado al detalle (partiendo de la base de alguien con un mínimo de experiencia en Java que quiere adentrarse en el mundo Android) .

Un curso que pienso seguir hasta donde me deje mi limitado tiempo libre que dedico a estas aficiones.

Gracias por tu esfuerzo y dedicación.

Un saludo.

Responder
josé 05/06/2016 - 5:50

Estimados,
Los molesto ya que trato de hacer una app utilizando la camara, necesito capturar fotos pero debe aparecer una imagen tipo marco en el foco, este marco no debe aparecer en la imagen, es solo una guía, como puedo hacer esto?…
por ejemplo esta camara tiene en el foco un marco como imagen, el rectangulo verde, pero que al momento de tomar la foto este marco no aparecerá…
Gracias por todo… saludos.

https://lh3.googleusercontent.com/-hp_8QgeSSmw/VzxycQzMr7I/AAAAAAAAM-8/1KcZAfrfllAxu56ibjTmiFvWXQMLNoc0g/w530-h398-p-rw/TS560x560.jpg

Responder
Andres Felipe Vasquez Ramirez 14/06/2016 - 20:45

Hola a todos,

Soy un poco nuevo en Java y sobre todo en android, y mas que migro de PHP aun tengo muchas falencias, seguí el manual al pie de la letra y me sale un error, he intentado declarar la variable y no me funciona,

Lineas del error:

/home/anvargear/AndroidStudioProjects/UniversityNotes/app/src/main/java/anvargear/universitynotes/MainActivity.java
Error:(19, 9) error: cannot find symbol variable btnAceptar
Error:(27, 55) error: cannot find symbol class SaludoActivity
Error:(22, 9) error: cannot find symbol variable btnAceptar
/home/anvargear/AndroidStudioProjects/UniversityNotes/app/src/main/java/anvargear/universitynotes/AverageNotes.java
Error:(14, 9) error: cannot find symbol variable txtSaludo
Error:(14, 22) error: cannot find symbol class TextView
Error:(20, 9) error: cannot find symbol variable txtSaludo
:app:compileDebugJavaWithJavac FAILED

Responder
santiago 06/07/2016 - 1:53

muy buen tutorial, mas sabiendo de la complejidad de este emulador, era necesario hacerlo de manera impecable. no tuve ningun problema excepto porque en la primera compilacion tardo demasiado y no hizo nada. luego instale un par de actualizaciones que me reclamaba el ide y habilite el haxm en el bios (que no se llama asi en el menu) cuando se lo habillite en el compilador me dio un error de vt-x, costo un poco encontrar que variable era en el bios (intel virtual system creo que se llama), pero luego de resetear anduvo perfecto, me compilo en 15 segundos.
me asombro lo estricto del ide y la informacion que da, acostumbrado a trabajar con java script y php, hace tiempo que no trabajaba con compiladores. bue, muchas gracias, seguire estudiando

Responder
Rafael Vargas 09/07/2016 - 20:36

Hola, tengo este error que no me deja correr el primer proyecto

Error:Execution failed for task ‘:app:processDebugResources’.
> com.android.ide.common.process.ProcessException: org.gradle.process.internal.ExecException: Process ‘command ‘C:\Users\Rafael\AppData\Local\Android\Sdk\build-tools\24.0.0\aapt.exe» finished with non-zero exit value 1

Responder
Sebastian Alzate 13/08/2016 - 18:56

Excelente tutorial amigo, todo muy entendible y bien explicado, algo que no me queda claro es en la parte del intent en la segunda activity, cuando el bundle que declaramos obtiene el valor del intent, como sabe de cual intent obtenerla?

Responder
Samuel Ochoa 19/08/2016 - 17:32

oye tambien tengo un error, es el siguiente:

error: cannot find symbol variable txtNombre

Responder
JimmyTutoriales 21/08/2016 - 0:35

Excelente post, me ayudó demasiado ahora que empiezo a desarrollar apps, saludos!

Responder
Juan Carlos Villafuerte Rondon 24/08/2016 - 18:56

Muy buen ejemplo me ayudo mucho en mi aprendizaje, y seria bueno que sigan compartiendo sus conocimientos…gracias!!!

Responder
Entorno de desarrollo Android (Android Studio) | sgoliver.net 27/09/2016 - 18:13

[…] la estructura y componentes de un proyecto Android, y crearemos y probaremos sobre el emulador una aplicación sencilla para poner en práctica todos los conceptos […]

Responder
Componentes de una aplicación Android | sgoliver.net 27/09/2016 - 18:19

[…] el siguiente artículo empezaremos ya a ver algo de código, analizando al detalle una aplicación […]

Responder
Camilo 08/10/2016 - 22:20

Hola, tengo un problema, en el MainActivity.java me sale un error en una sola línea de código, txtNombre = (EditText)findViewById(R.id.txtNombre); txtNombre me queda en rojo y no en violeta como btnAceptar.
Podrias ayudarme?

Responder
Marcelo 18/10/2016 - 14:07

Muchas gracias, muy bueno el tutorial para los que estamos empezando con Android

Responder
Juan Carlos Villafuerte 12/11/2016 - 16:27

Hola, una pregunta quisiera saber como capturar el texto de un edittext y usarlo en una condicion.
ejemplo:

si (textedit=»pepito» entonces){
TOAST=»nombre correcto»
}

gracias de antemano….

Responder
Leonardo 04/12/2016 - 20:02

Hola, excelente curso y gracias por compartirlo. Tengo un problema al tratar de ejecutar esta app en mi teléfono, cuando ingreso el nombre y presiono el botón para pasar a la siguiente actividad, la aplicación se detiene y se cierra «Unfortunately, your App has stopped». ¿Podrías ayudarme?

Responder
Emanuel 21/01/2017 - 20:51

guuao chabon, muchas muchas muchas gracias por todo esto que compartis… la verdad un caño. voy a probar a ver que sale, te mando un abrazo hermanito. y saludos ttmb a todos los que comentaron, futuros colegas .. jajjaja a creaaaar1!!!!!

Responder
luis mansilla 24/01/2017 - 3:32

Muy bueno,en verdad. gracias por compartir tus conocimientos. Si hay grupo de facebook o youtube indícalo para seguirte también por ahí,y apoyarte de alguna forma

Responder
Leonardo Ezquerro 01/03/2017 - 22:45

funciono perfecto, funciono bien la APP, muchas gracias!

Responder
Jorge Sanchez 26/03/2017 - 2:35

Excelente,

solo falto definir esta linea en el archivo strings.xml
nombre de la app

Responder
Miguel 08/06/2017 - 23:09

Excelente este tutorial. Muy agradecido por compartirlo.

Responder
michael herrera 22/08/2017 - 21:42

hola tengo problemas en el strings me sale un mensaje: multiple root tags. que tengo que modificar?

Star 3

Responder
Franz 22/06/2018 - 3:09

Buenas
Quisiera ayuda con una aplicación
En la cual tengo que introducir datos como positivo o negatr y me tienen que dar la cantidad de cada una

Responder
marc58 20/05/2019 - 0:47

excelente ayuda para los principiantes en aplicaciones android. Mil gracias

Responder
marc58 20/05/2019 - 0:50

excelente ayuda para principiantes en android studio. gracias

Responder
Entorno de desarrollo Android (Android Studio) - sgoliver.net 16/04/2020 - 23:15

[…] un proyecto Android, y crearemos y probaremos sobre el emulador una aplicación sencilla para poner en práctica todos los conceptos […]

Responder
Interfaz de usuario en Android: Layouts | sgoliver.net 06/05/2020 - 8:58

[…] el artículo anterior del curso, donde desarrollamos una sencilla aplicación Android desde cero, ya hicimos algunos […]

Responder

Responder a nickenino Cancelar respuesta

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. Aceptar Más Información

Política de Privacidad y Cookies