¡Descarga Desarrollo de una Aplicación Android Sencilla con Android Studio y más Apuntes en PDF de Programación Java solo en Docsity!
Desarrollando una aplicación
Android sencilla (Android
Studio)
Para empezar a escribir algo de código, lo mejor es comenzar por escribir una aplicación sencilla. El clásico Hola Mundo sería muy básico para Android. Así que haremos un Hola Usuario , que es igual de sencillo 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 no está mal aprender muchos conceptos básicos,… para empezar. Por dibujarlo para entender mejor lo que queremos conseguir, sería algo tan sencillo como lo siguiente: Vamos a partir de un proyecto igual al del ejemplo que creamos en un tema anterior, al que llamamos 02 HolaMundo. Esta vez lo llamaremos 04 HolaUsuario. 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 hemos 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/paquete.java/MainActivity.java , encontraremos el código java que determina la lógica de la pantalla. Vamos a modificar en primer lugar el aspecto de la ventana 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 del fichero activity_main.xml por el siguiente: 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6
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 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). Estas propiedades son las únicas obligatorias para los componentes y tomarán 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 alto o ancho 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 normal (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: 1 2 3 4 Y la segunda alternativa, la utilizada en el 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: ”. 1 2 3 4 5 ... Escribe tu nombre: ... 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 2 3 4 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.
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, pulsaremos el botón derecho sobre la carpeta /src/main/java/tu.paquete.java/ y seleccionaremos la opción de menú New / Activity / Empty Activity. En el cuadro de diálogo que 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 java), que llamaremos activity_saludo, y el nombre del paquete java de la actividad, donde podemos dejar el valor por defecto. Pulsaremos Finish y Android Studio creará los nuevos ficheros SaludoActivity.java 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.
botón. Para ello definiremos ambas referencias como atributos 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. 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2 1 package dam.miguel.android.a04holausuario; //.. 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); //Obtenemos una referencia a los controles de la interfaz txtNombre = (EditText)findViewById(R.id.txtNombre); btnAceptar = (Button)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 tomar cuando pulsemos el botón de la pantalla. 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: 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2 1 2 2 2 3 2 4 2 5 2 6 package dam.miguel.android.a04holausuario; //... import android.content.Intent; import android.os.Bundle; import android.view.View; 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 botón btnAceptar.setOnClickListener(new View.OnClickListener() { @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); } }); } }
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 creamos un objeto Bundle, que puede contener una lista de pares clave-valor con toda la información a pasar entre actividades. En nuestro caso sólo añadimos un dato de tipo String mediante el método putString(clave, valor). Como clave para nuestro dato yo he elegido el literal “ NOMBRE ” aunque podéis 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 método getText() y convirtiendo este contenido a texto mediante toString() (más adelante en el curso veremos por qué es necesaria esta conversión). Tras esto añadiremos la información al intent mediante el método putExtras(). Si necesitáramos pasar más datos entre una actividad y otra no tendríamos más que repetir estos pasos para todos los parámetros necesarios. Con esto hemos finalizado 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 el método getIntent() y recuperaremos su información asociada (objeto Bundle) mediante el método getExtras(). Hecho esto tan sólo nos queda construir el texto de la etiqueta mediante su método setText(texto) y recuperando el valor de
nuestra clave almacenada en el objeto Bundle mediante getString(clave). 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2 1 2 2 2 3 2 4 2 5 package dam.miguel.android.a04holausuario; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.widget.TextView; public class SaludoActivity extends AppCompatActivity { private TextView txtSaludo; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_saludo); //Localizar los controles txtSaludo = (TextView)findViewById(R.id.txtSaludo); //Recuperamos la información pasada en el intent Bundle bundle = this.getIntent().getExtras(); //Construimos el mensaje a mostrar txtSaludo.setText("Hola " + bundle.getString("NOMBRE")); } } 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 ( AndroidManifest.xml ) para definir, entre otras cosas, los diferentes elementos que la componen. Por tanto, todas las actividades de
Podemos ver como para cada actividad se indica entre otras cosas el nombre de su clase java 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: 1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 2 0 2 1 2 2 2 apply plugin: 'com.android.application' android { compileSdkVersion 23 buildToolsVersion "23.0.3" defaultConfig { applicationId "net.sgoliver.android.holausuario" minSdkVersion 16 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']) testCompile 'junit:junit:4.12' compile 'com.android.support:appcompat-v7:23.4.0' }
3 2 4 2 5 2 6 Gradle es el nuevo sistema de compilación y construcción que ha adoptado Google para Android Studio. 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 el plugin para Android mediante la sentencia “apply plugin“. A continuación definiremos 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 (es uno de los componentes que podemos descargar/actualizar desde el SDK Manager), 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 preocupamos por ahora de esto). Durante el curso iremos viendo con más detalle todos estos elementos. El ultimo elemento llamado “dependencies” también es importante y nos servirá entre otras cosas para definir las librerías externas que utilizaremos en la aplicación. Por defecto vemos que se añade la librería de compatibilidad appcompat-v7 que nos permite utilizar la Action Bar en la mayoría de versiones de Android, la librería junit para realizar tests unitarios, y todos los fichero .jar que incluyamos en la carpeta /libs. Llegados aquí, y si todo ha ido bien, deberíamos poder ejecutar el proyecto sin errores y probar nuestra aplicación en el emulador, pero para ello tendremos que definir primero uno. Vamos a describir los pasos para hacerlo.
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 instalar el entorno, aunque tenemos la posibilidad de descargar e instalar nuevas versiones desde esta misma pantalla. En este caso utilizaremos 6.0 Marshmallow (API
para x86_64 en este primer AVD (podemos crear tantos como queramos para probar nuestras aplicaciones sobre distintas condiciones). 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, teclado físico, … Recomiendo pulsar el botón “ Show Advanced Settings ” para ver 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 AVD, por lo que podremos comenzar a probar nuestras aplicaciones sobre él.
