Manual Android Intruduccion

ING.
MARCO ANTONIO AREVALO

ZAMBRANO - CHILE
TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017
CONTENIDO: ANDROID
CONTENIDO: ANDROID Nivel 1 .................................................................................................... 2
ANDROID ............................................................................................................................................. 3
APIS EN ANDROID ............................................................................................................................ 3
ARQUITECTURA EN ANDROID .......................................................................................................... 6
ENTORNO DE DESARROLLO ............................................................................................................... 7
1. Descargar el SDK de Android. ............................................................................... 7
2. Crear un emulador ..................................................................................................... 12
3. Crear proyecto en Android .................................................................................... 14
ESTRUCTURA DE UN PROYECTO ANDROID .................................................................................. 18
Carpeta /src/ .................................................................................................................. 19
Carpeta /res .................................................................................................................... 19
Carpeta /gen/ .................................................................................................................. 20
FICHERO ANDROIDMANIFEST.XML................................................................................................ 21
ANDROID TIPS ................................................................................................................................... 21
Aplicacin en Android No.1 .................................................................................................. 21
Cdigo java (MainActivity.java) ................................................................................... 22
Cdigo archivo layout (activity_main.xml) ............................................................. 22
Diseo archivo layout (activity_main.xml) ............................................................. 23
Cdigo archivo strings.xml .............................................................................................. 23
Cdigo archivo AndroidManifiest.xml .......................................................................... 24
Aplicacin en Android No.2 .................................................................................................. 25
Cdigo java (MainActivity.java) ................................................................................... 25
Cdigo java (Segundo Activity.java) .......................................................................... 25
Cdigo archivo layout (activity_main.xml) ............................................................. 27
Cdigo archivo layout (activity_segundo.xml) ...................................................... 27
Cdigo archivo string.xml ................................................................................................ 28
Cdigo archivo AndroidManifiest.xml .......................................................................... 28
Desarrollando una aplicacin Android sencilla (Android Studio) ................... 29

ANDROID
Android es un sistema operativo basado en el kernel de Linux

diseado principalmente para dispositivos mviles con pantalla
tctil, como telfonos inteligentes o tabletas, y tambin para
relojes inteligentes, televisores y automviles, inicialmente
desarrollado por Android, Inc.
Google respald econmicamente y ms tarde compr esta empresa

en Julio 2005.En Noviembre 2007, nace la Open Handset Alliance
Consorcio de empresas unidas con el objetivo de desarrollar
estndares abiertos para mviles.
El primer producto Android para mviles es construida sobre el

kernel de Linux 2.6
APIS EN ANDROID
Los nombres de las versiones de Android se escogen de nombres

de postres y siguiendo la secuencia del abecedario!
Android CUPCAKE - versin 1.5

Lanzamiento: Abril del 2009
Funciones: Teclado QWERTY virtual, widgets, captura de
video,copiar&pegar, subir videos a Youtube en forma directa.
Notas: Marca el inicio de este sistema operativo.
API 3
Android DONUT - versin 1.6

Lanzamiento: Septiembre 2009
Funciones: Navegacin en Google Maps paso-a-paso, mejora en el
interfaz de la cmara de foto y video, bsquedas por voz.
Nota: Esta versin era muy barata y no encareca el costo de
los dispositivos. Inicia de manera importante el crecimiento
de la comunidad de desarrolladores.
API 4
Android ECLAIR - versin 2.0

Lanzamiento: Diciembre 2009
Funciones: Zoom digital de la cmara de fotos y video, mejoras
en Google Maps, nuevo navegador de internet con soporte de
video e incluso de Flash, salvapantallas animadas.

Nota: Comienza a demostrar la robustez y estabilidad como

sistema operativo para dispositivos mviles.
API 5
Android FROYO - versin 2.2

Lanzamiento: Mayo 2010
Funciones: mejora de memoria, mucho mas veloz que las versiones
anteriores, WiFi incluido, soporte de correo electrnico
Microsoft Exchange y video llamada. Soporta Flash
Nota: Ya tomando su sitio de honor entre la mayora de los
dispositivos mviles a nivel mundial. Excelente aceptacin por
parte de los usuarios.
API 8
Android GINGERBREAD - versin 2.3

Funciones: Mejora del soporte de video online, mejora de la
gestin de la energa (y consumo de la batera), mejora del
teclado virtual, soporte para pagos mediante NFC.
Nota: Abre mas posibilidades para usuarios totalmente
conectados. API 9, 10
Android HONEY COMB -versin 3.0/3.4

Funciones: Sistema operativo optimizado para tablets, posee
plenas funcionalidades multitareas (multitasking) para cambiar
de aplicaciones en uso dejando las dems en espera visibles en
una columna, soporte Flash y DivX, aparte de los navegadores
privados tradicionales integra Dolphin, home page
personalizable y widgets.
Nota: Esta versin est optimizada para Tablets, manteniendo
en smartphone la versin 2.3
API 11
Android ICECREAM SANDWICH - versin 4.0

Lanzamiento: Finales 2011
Funciones: Diseado para todas las plataformas (smartphones,
tablets y netbooks de todas las medidas), pantalla principal
con imgenes 3D, barras de estado y widgets redimensionables,
reconocimiento facial, mejora de reconocimiento de voz; soporte
USB para teclados y controles para PS3.
Nota: Novedades y mejoras en la navegacin e interfaz, con el
objetivo de dinamizar y facilitar la experiencia del usuario.
API 14

Android JELLY BEAN - versin 4.3

Lanzamiento: Julio 2013
Funciones: Motor multi-idioma de Sntesis de habla para
permitir a cualquier aplicacin de Android "hablar" una cadena
de texto, fotos panormicas con "Photo Sphere", etc.
Nota: Por primera vez en Android se incluyen los idiomas hebreo,
rabe, afrikans, amhrico, hindi, suajili y zul. Posee un
sistema de localizacin Wi-Fi en segundo plano.
API 16
Android KITKAT - versin 4.4

Lanzamiento: Finales 2013
Funciones: Optimizacin de mltiples tareas, vista web en
Chrome, fotos en HDR+, etc.
Nota: Integracin de SMS en Hangouts, emoji.
API 19
Android LOLLIPOP - versin 5.0

Funciones: Rediseo de la interfaz de usuario basado en
Material design, cambios en las notificaciones, pantalla de
bloqueo, optimizacin de la batera.
API 21
Android Marshmallow versin 6.0

Funciones: Soporte nativo para el reconocimiento de huellas
digitales. Un nuevo sistema de administracin de energa
conocida como "doze" reduce las actividades en fondo del
dispositivo cuando el sistema operativo detecta que el
dispositivo no est siendo tocado fsicamente.
API 23

ARQUITECTURA EN ANDROID
Android est formado por 4 capas, cada una de ellas basadas en

software libre.
1.- El ncleo Linux
El ncleo de Android est formado por el sistema operativo

Linux versin 2.6. Esta capa proporciona servicios como la seguridad,
el manejo de la memoria, el multiproceso, la pila de protocolos y el
soporte de drivers para dispositivos.
Esta capa del modelo acta como capa de abstraccin entre el

hardware y el resto de la pila. Por lo tanto, es la nica que es
dependiente del hardware.
2.1- Runtime de Android
Est basado en el concepto de mquina virtual utilizado en

Java. Dado las limitaciones de los dispositivos donde ha de correr
Android (poca memoria y procesador limitado) no fue posible utilizar
una mquina virtual Java estndar. Google tom la decisin de crear

una nueva, la mquina virtual Dalvik, que respondiera mejor a estas

limitaciones.
Tambin se incluye en el Runtine de Android el core libraries

con la mayora de las libreras disponibles en el lenguaje Java.
2.2.- Libreras nativas
Incluye un conjunto de libreras en C/C++ usadas en varios

componentes de Android. Estn compiladas en cdigo nativo del
procesador. Muchas de las libreras utilizan proyectos de cdigo
abierto.
3.- Entorno de aplicacin
Proporciona una plataforma de desarrollo libre para

aplicaciones con gran riqueza e innovaciones (sensores,
localizacin, servicios, barra de notificaciones,).
Esta capa ha sido diseada para simplificar la reutilizacin

de componentes. Las aplicaciones pueden publicar sus capacidades y
otras pueden hacer uso de ellas (sujetas a las restricciones de
seguridad). Este mismo mecanismo permite a los usuarios reemplazar
componentes.
Una de las mayores fortalezas del entorno de aplicacin de

Android es que se aprovecha el lenguaje de programacin Java.
4.- Aplicaciones
Este nivel est formado por el conjunto de aplicaciones

instaladas en una mquina Android. Todas las aplicaciones han de
correr en la mquina virtual Dalvik para garantizar la seguridad del
sistema.
Normalmente las aplicaciones Android estn escritas en Java.

Para desarrollar aplicaciones en Java podemos utilizar el Android
SDK. Existe otra opcin consistente en desarrollar las aplicaciones
utilizando C/C++. Para esta opcin podemos utilizar el Android NDK
(Native Development Kit).
ENTORNO DE DESARROLLO
1. Descargar el SDK de Android.

El SDK de la plataforma Android se puede descargar desde

http://developer.android.com/sdk/index.html junto con el IDE de
Android Studio


Este descarga, incluye tambien el ultimo API. Si se desea

descargar otra API u otras herramientas tendremos que descargar su
target correspondiente.


2. Crear un emulador

Para configurar el emulador slo se debe ingresar a la opcin

AVD Manager
Indicar el tamao del emulador
Seleccionamos la imagen del sistema

Ingresamos nombre del emulador
3. Crear proyecto en Android

Al momento de crear un proyecto nuevo de android, aparecer una

primera pantalla donde colocaremos el nombre de la aplicacin, el
nombre del proyecto, el paquete java
Luego seleccionamos la versin mnima del SDK que aceptar nuestra

aplicacin (Minimum Required SDK) para cada tipo de dispositivo

La siguiente pantalla es para elegir el tipo de Actividad

principal de la aplicacin. Dejar todo por defecto, la pantalla
principal ser del tipo BlankActivity.

El ltimo paso es para indicar los datos de esta actividad

principal, nombre de la clase java asociada y el nombre del layout
.xml
Luego pulsamos Finish y Android Studio crear un nuevo proyecto

Android con esta estructura:

ESTRUCTURA DE UN PROYECTO ANDROID

Cuando creamos un nuevo proyecto Android en Android Studio se
genera automticamente la estructura de carpetas necesaria para
poder generar posteriormente la aplicacin. Esta estructura ser
comn a cualquier aplicacin, independientemente de su tamao y
complejidad. En la siguiente imagen vemos los elementos creados
inicialmente para un nuevo proyecto Android:

Describamos los elementos principales.
Carpeta /src/
Contiene todo el cdigo fuente de la aplicacin, cdigo de la

interfaz grfica, clases auxiliares, etc. Inicialmente, Eclipse
crear por nosotros el cdigo bsico de la pantalla (Activity)
principal de la aplicacin, siempre bajo la estructura del paquete
java definido.
Carpeta /res
Contiene todos los ficheros de recursos necesarios para el

proyecto: imgenes, vdeos, cadenas de texto, etc. Los diferentes
tipos de recursos de debern distribuir entre las siguientes
carpetas:
/res/drawable/ Contiene las imgenes [y otros elementos

grficos] usados en por la aplicacin. Para definir diferentes

recursos dependiendo de la resolucin y densidad de la pantalla

del dispositivo se suele dividir en varias subcarpetas:
/drawable-ldpi (densidad baja)
/drawable-mdpi (densidad media)
/drawable-hdpi (densidad alta)
/drawable-xhdpi (densidad muy alta)
/res/layout/ Contiene los ficheros de definicin XML de las

diferentes pantallas de la interfaz grfica. Para definir
distintos layouts dependiendo de la orientacin del dispositivo
se puede dividir en dos subcarpetas:
o /layout (vertical)
o /layout-land (horizontal)
/res/color/ Contiene ficheros XML de definicin de colores

segn estado.
/res/menu/ Contiene la definicin XML de los mens de la
aplicacin.
/res/xml/ Contiene otros ficheros XML de datos utilizados por
la aplicacin.
/res/raw/ Contiene recursos adicionales, normalmente en formato
distinto a XML
/res/values/ Contiene otros ficheros XML de recursos de la
aplicacin, como por ejemplo cadenas de texto (strings.xml),
estilos (styles.xml), colores (colors.xml), arrays de valores
(arrays.xml), etc.
Entre los recursos creados por defecto, cabe destacar el layout

activity_main.xml, que contiene la definicin de la interfaz
grfica de la pantalla principal de la aplicacin
Carpeta /gen/
Contiene una serie de elementos de cdigo generados

automticamente al compilar el proyecto. Cada vez que generamos
nuestro proyecto, la maquinaria de compilacin de Android genera por
nosotros una serie de ficheros fuente en java dirigido al control de
los recursos de la aplicacin.
Esta clase R contendr en todo momento una serie de constantes

con los ID de todos los recursos de la aplicacin incluidos en la

carpeta /res/, de forma que podamos acceder facilmente a estos

recursos desde nuestro cdigo a travs de este dato. As, por
ejemplo, la constante R.drawable.icon contendr el ID de la imagen
icon.png contenida en la carpeta/res/drawable/.
FICHERO ANDROIDMANIFEST.XML
Contiene la definicin en XML de los aspectos principales de
la aplicacin, como por ejemplo su identificacin (nombre, versin,
icono,...), sus componentes (pantallas, mensajes,...), o los
permisos necesarios para su ejecucin.
ANDROID TIPS
Si se ejecuta un proyecto en un dispositivo virtual y luego se

hacen modificaciones de cdigo o se corre en modo debug, no es
necesario cerrar la instancia del AVD sino que simplemente hay
que presionar el botn Run.
Utilizar siempre Relative Layouts para tener GUI utilizables
en todas las resoluciones.
Aprovechar los recursos .xml disponibles, por ejemplo strings,
colours y styles.
Definir en el Manifest de la aplicacin todas las
caractersticas de la aplicacin, de esta manera se evitar
que se instale en dispositivos que no la soporten evadiendo
los puntajes y comentarios negativos.
Ubicar en las carpetas especficas para las distintas pantallas
las imgenes diseadas para las distintas resoluciones.
El xito de una aplicacin para Android radica principalmente
en el diseo de la interfaz grfica y la interaccin con los
recursos del telfono
La mayores optimizaciones se pueden hacer en base al diseo de
las UI.
Utilizar sp (space independent pixels) o dip (distance
independent pixels) en vez de px para definir medidas ya que
de esta forma podremos tenes elementos escalables a las
distintas densidades de pantallas.
Hacer las pruebas sobre muchas configuraciones de dispositivos
virtuales distintas.
Aplicacin en Android No.1

Descripcin de la app: Esta aplicacin constar de un pequeo

formulario que contiene un EditText y un elemento Button, la
accin del botn mostrar una alerta, pudiendo salir de la
aplicicacin o no. Tambin se escribirn mensajes en el log de
la app.
Palabras claves: Activity, Layout, TextView, EditText, Button,
onClick, id, R, Log, Toast.
Objetivos: manipular elementos view de android, realizar
interfaz grfica, manejo de eventos, mensajes de alerta y/o
notificaciones al usuario, finalizar aplicacin, depuracin de
aplicaciones, ejecucin de aplicaciones en el emulador.
Cdigo java (MainActivity.java)
Cdigo archivo layout (activity_main.xml)

Diseo archivo layout (activity_main.xml)
Cdigo archivo strings.xml

Cdigo archivo AndroidManifiest.xml

Aplicacin en Android No.2
Descripcin de la app: Manejo de varias actividades en una app,

envio y recuperacin de datos entre actividades
Palabras claves: Activity, Layout, TextView, EditText, Button,
onClick, id, R, Log, Toast, Alert, Intent.
Objetivos: iniciar otras actividades desde la actividad
principal, envo y recuperacin de datos entre actividades.
Cdigo java (MainActivity.java)
Cdigo java (Segundo Activity.java)


Cdigo archivo layout (activity_main.xml)
Cdigo archivo layout (activity_segundo.xml)

Cdigo archivo string.xml
Cdigo archivo AndroidManifiest.xml

Desarrollando una aplicacin

Android sencilla (Android
Studio)
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 2.0
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:
<?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:inputType="text" />
<Button android:id="@+id/btnAceptar"
android:text="@string/aceptar" />
</LinearLayout>

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:
android:text="Escribe tu nombre:" />
Y la segunda alternativa, la utilizada en el ejemplo, consistira en

definir primero una nueva cadena de texto en el fichero de
recursos /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 la cadena como valor de

la propiedad android:text, siempre precedido del prefijo @string/,
de la siguiente forma:
android:text="@string/nombre" />
Esta segunda alternativa nos permite tener perfectamente localizadas

y agrupadas todas las cadenas de texto utilizadas en la aplicacin,
lo que nos podra facilitar por ejemplo la traduccin de la

aplicacin a otro idioma. 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 ventana activity_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:
package net.webcommservice.android.holausuario;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
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 AppCompatActivity, que
soporta entre otras cosas la utilizacin de la Action 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.
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 / Empty Activity.
En el cuadro de dilogo 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 aadiendo esta vez tan slo
un LinearLayout como contenedor y una etiqueta (TextView) para
mostrar el mensaje personalizado al usuario.
Para esta segunda pantalla el cdigo que incluiramos sera el

siguiente:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/lytContenedorSaludo"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView android:id="@+id/txtSaludo"
android:text="" />
</LinearLayout>
Por su parte, si revisamos ahora el cdigo de la clase

java SaludoActivity veremos que es anlogo a la actividad principal:
public class SaludoActivity extends AppCompatActivity {
@Override
setContentView(R.layout.activity_saludo);
}
}
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.

//..
import android.widget.Button;
import android.widget.EditText;
private EditText txtNombre;

private Button btnAceptar;
@Override
//Obtenemos una referencia a los controles de la interfaz

txtNombre = (EditText)findViewById(R.id.txtNombre);
btnAceptar = (Button)findViewById(R.id.btnAceptar);
}
}
Como vemos, hemos aadido tambin varios import adicionales (los de

las clases Buttony EditText) 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:
//...
import android.content.Intent;
import android.view.View;
private EditText txtNombre;

private Button btnAceptar;
@Override
//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() {
@Override
public void onClick(View v) {
//Creamos el Intent
Intent intent =
new Intent(MainActivity.this, SaludoActivity.class);
//Creamos la informacin a pasar entre actividades

Bundle b = new Bundle();
b.putString("NOMBRE", txtNombre.getText().toString());
//Aadimos la informacin al intent

intent.putExtras(b);
//Iniciamos la nueva actividad

startActivity(intent);
}
});
}
}
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 clave-valor 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).
import android.widget.TextView;
public class SaludoActivity extends AppCompatActivity {
private TextView txtSaludo;
@Override
setContentView(R.layout.activity_saludo);
//Localizar los controles

txtSaludo = (TextView)findViewById(R.id.txtSaludo);
//Recuperamos la informacin 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 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.
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="net.webcommservice.android.holausuario">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name=".SaludoActivity"></activity>
</application>
</manifest>
Podemos ver como para cada actividad se indica entre otras cosas el
nombre de su clase java asociada como valor del
atributo android:name, ms 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 ms interno, en
nuestro caso el que est dentro del mdulo app. Veamos qu
contiene:
apply plugin: 'com.android.application'
android {
compileSdkVersion 23
buildToolsVersion "23.0.3"
defaultConfig {
applicationId "net.webcommservice.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'])
testCompile 'junit:junit:4.12'
compile 'com.android.support:appcompat-v7:23.3.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), la 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 ProGuardsi
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, la
librera junit para realizar tests unitarios, 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.
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

Manual Android Intruduccion

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Manual Android Intruduccion

Hochgeladen von

Copyright:

Verfügbare Formate

ING.

MARCO ANTONIO AREVALO

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Android es un sistema operativo basado en el kernel de Linux

Google respald econmicamente y ms tarde compr esta empresa

El primer producto Android para mviles es construida sobre el

Los nombres de las versiones de Android se escogen de nombres

Android CUPCAKE - versin 1.5

Android DONUT - versin 1.6

Android ECLAIR - versin 2.0

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Nota: Comienza a demostrar la robustez y estabilidad como

Android FROYO - versin 2.2

Android GINGERBREAD - versin 2.3

Android HONEY COMB -versin 3.0/3.4

Android ICECREAM SANDWICH - versin 4.0

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Android JELLY BEAN - versin 4.3

Android KITKAT - versin 4.4

Android LOLLIPOP - versin 5.0

Android Marshmallow versin 6.0

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Android est formado por 4 capas, cada una de ellas basadas en

1.- El ncleo Linux

El ncleo de Android est formado por el sistema operativo

Esta capa del modelo acta como capa de abstraccin entre el

2.1- Runtime de Android

Est basado en el concepto de mquina virtual utilizado en

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

una nueva, la mquina virtual Dalvik, que respondiera mejor a estas

Tambin se incluye en el Runtine de Android el core libraries

2.2.- Libreras nativas

Incluye un conjunto de libreras en C/C++ usadas en varios

3.- Entorno de aplicacin

Proporciona una plataforma de desarrollo libre para

Esta capa ha sido diseada para simplificar la reutilizacin

Una de las mayores fortalezas del entorno de aplicacin de

Este nivel est formado por el conjunto de aplicaciones

Normalmente las aplicaciones Android estn escritas en Java.

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

El SDK de la plataforma Android se puede descargar desde

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Este descarga, incluye tambien el ultimo API. Si se desea

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Para configurar el emulador slo se debe ingresar a la opcin

Indicar el tamao del emulador

Seleccionamos la imagen del sistema

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Ingresamos nombre del emulador

3. Crear proyecto en Android

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

Al momento de crear un proyecto nuevo de android, aparecer una

Luego seleccionamos la versin mnima del SDK que aceptar nuestra

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

La siguiente pantalla es para elegir el tipo de Actividad

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

El ltimo paso es para indicar los datos de esta actividad

Luego pulsamos Finish y Android Studio crear un nuevo proyecto

TALLER INTERNACIONAL DE APLICACIONES MOVILES WEBCOMMSERVICE 2017

ESTRUCTURA DE UN PROYECTO ANDROID