módulo 1: implementación de y usables
TRANSCRIPT
Módulo 1: Implementación de APPS interactivas y usables
1
Programación para dispositivos móviles II
Módulo 1: Implementación de APPS interactivas y usables
Autor: Ing. Yamil Buenaño Palacios
Fecha de actualización: 11 de julio de 2016
Módulo 1: Implementación de APPS interactivas y usables
2
Introducción
El siguiente módulo de Programación de Aplicaciones Móviles II es la base fundamental
para la formación en el área de Ingeniería de Software. Con el itinerario del presente módulo los
estudiantes podrán implementar aplicaciones para dispositivos móviles en Android que sean
capaces de usar y organizar la información de forma interactiva. Por otra parte, se analizarán y
utilizarán buenas prácticas para el desarrollo y buen diseño de una aplicación para dispositivos
móviles. También se analizarán y desarrollarán temáticas como los intent, objetos que tienen
como función navegar de una página a otra; los listview, para la generación de listas; webview, para
visualizar páginas; los hilos, para el manejo de procesos, y los manifest, para vincular las actividades
a la aplicación. Además, se propondrán actividades para fijar y evaluar la temática orientada.
Competencias
El desarrollo de este módulo permitirá al alumno alcanzar las siguientes competencias:
Diseñar aplicaciones con características especiales de los dispositivos móviles de última
generación, las tecnologías de comunicación asociadas y las diferencias que rigen el
desarrollo de aplicaciones para este nuevo entorno frente a los entornos tradicionales
(escritorio y web).
Implementar apps con una buena apariencia visual para el uso y acceso de los usuarios.
Entender los mecanismos para el acceso a datos mediante dispositivos móviles y la
programación de los mismos.
Adaptar aplicaciones web al dispositivo móvil.
Justificación
Teléfono móvil se entiende como un dispositivo electrónico de comunicación,
normalmente de diseño reducido y sugerente, basado en la tecnología de ondas de radio (es decir,
transmite por radiofrecuencia), que tiene la misma funcionalidad que cualquier teléfono de línea
fija. Su rasgo característico principal es que se trata de un dispositivo portable e inalámbrico.
Esto es que la realización de llamadas no es dependiente de ningún terminal fijo y que no requiere
de ningún tipo de cableado para llevar a cabo la conexión a la red telefónica (Basterretche, 2007).
Con la evolución de los dispositivos móviles han cambiado también los productos que
estos pueden tener. Además, con el pasar del tiempo, se han convertido en instrumento de
mínima capacidad de cálculo, con disponibilidad de 512Mb en memoria y 1Ghz de
procesamiento aproximadamente, lo que posibilita construir apps anheladas. Estas posibilidades
han dado como resultado la concepción de nuevos conceptos y tecnologías, como es el caso del
tema de esta asignatura, la Programación de Dispositivos Móviles II.
Módulo 1: Implementación de APPS interactivas y usables
3
Objetivos del curso
Analizar y utilizar herramientas tecnológicas para la implementación de aplicaciones
móviles.
Analizar y evaluar la información requerida con el fin de proponer soluciones para
dispositivos móviles inteligentes en Android.
Diseñar aplicaciones móviles usables que permitan establecer conectividad con sistemas
de información internos y externos.
Implementar aplicaciones para dispositivos móviles que permitan automatizar y
consumir recursos de un sistema determinado.
Alcance
La asignatura posee 3 créditos académicos, los cuales están divididos en 3 módulos y
cada uno de 12 horas de clases. La orientación de la asignatura se impartirá de forma virtual, lo
que implica que el estudiante cursa los 3 créditos de forma online. La parte virtual incluye teoría
y práctica.
Durante el proceso de capacitación que el estudiante adelanta en línea se obtienen las
competencias prácticas y teóricas que conforman la asignatura. En la sesión de encuentros
virtuales el alumno profundizará y aclarará incertidumbres presentadas en la asignatura. En
concreto, los conocimientos que se adquieren son los relacionados con las competencias para
desarrollar aplicaciones para dispositivos móviles.
Población objeto
Este curso se impartirá en la Universidad Manuela Beltrán, cuya población objetivo son
los estudiantes del programa de Ingeniería de Software y específicamente los que cursan la
asignatura Programación para Dispositivos Móviles II.
Competencias del módulo
Diseñar interfaces de presentación para aplicaciones Android temporizadas.
Construir aplicaciones para dispositivos móviles usables e interactivas.
Implementar web móvil para aplicaciones en Android.
Utiliza el ambiente integrado de desarrollo Android para la implementación de
aplicaciones para dispositivos móviles.
Módulo 1: Implementación de APPS interactivas y usables
4
Ideograma
Módulo 1: Implementación de APPS interactivas y usables
5
Contenido
1. Interactividad y navegación de aplicaciones................................................................................ 6
1.1. Intent ......................................................................................................................................... 6
1.1.1. Enviar datos hacia otra actividad .................................................................................. 9
1.1.2. Acciones descriptivas sobre acciones ......................................................................... 11
1.2. ListView .................................................................................................................................. 12
1.2.1. Implementación de una lista ........................................................................................ 13
1.2.2. Adaptador ...................................................................................................................... 14
1.2.3. ListView-Adapter .......................................................................................................... 14
1.3. WebView ................................................................................................................................ 16
1.3.1. Elementos para visualizar páginas en Android ......................................................... 16
1.3.2. Cargar una URL en Android ....................................................................................... 18
1.4. Thread ..................................................................................................................................... 20
1.4.1. Construcción de hilos ................................................................................................... 20
1.4.2. Componentes de un hilo .............................................................................................. 22
1.4.3. Componentes de un toast ............................................................................................. 24
1.4.4. Estructura de un toast .................................................................................................... 24
1.4.5. Constantes de la clase toast ........................................................................................... 25
1.5. Manifest .................................................................................................................................. 27
2. Composición de una aplicación Android .................................................................................. 28
2.1. Estructura de una aplicación Android ................................................................................ 28
3. Glosario .......................................................................................................................................... 33
4. Bibliografía ..................................................................................................................................... 33
Módulo 1: Implementación de APPS interactivas y usables
6
1. Interactividad y navegación de aplicaciones
En este apartado se definirán cinco elementos de Android que permitirán diseñar y construir
aplicaciones usables por los usuarios: los intent, las list, los webview, las thread y los toast.
1.1. Intent
Los intent son mensajes del sistema, que forman una red de comunicaciones entre las
aplicaciones Android dentro de un dispositivo. Los intent notifican a las aplicaciones desde
cambios hardware (como insertar una tarjeta SD), hasta la recepción de datos (cuando llega un
SMS) y eventos de aplicación (cuando se lanza una aplicación).
Aparte de los intent ya definidos por el sistema, se pueden definir nuevos intent para lanzar
otras actividades dentro de una aplicación o para informar de un evento producido en el
dispositivo a varios destinatarios.
Un intent es básicamente una estructura de datos que contiene una descripción abstracta de
una acción a realizar. Los atributos principales en un intent son:
Acción: acción a realizar en forma de cadena. Por ejemplo:
“android.intent.action.VIEW”.
Datos: expresados en forma de objetos URI. Por ejemplo:
“content://contacts/people/1”.
Si se juntan la acción y los datos del ejemplo anterior, se formaría un intent, que representa
la acción de mostrar la información de persona que tiene como identificador “1” dentro de los
contactos. Para ver la información, se podría usar una aplicación incorporada ya en Android, a
través de la invocación del intent. También un intent puede incorporar los siguientes atributos
secundarios:
Categoría: proporciona información adicional de la acción a ejecutar.
Tipo: especifica un tipo específico (un tipo MIME) de los datos del intent. Normalmente
este tipo se puede deducir a partir de los propios datos. Utilizando este atributo se fuerza
a un tipo explícito.
Componente: especifica el nombre exacto de una clase componente para ser usada por
el intent. Usualmente, esto es determinado a partir de la acción, el dato o tipo, y la
categoría. Especificando este atributo, el resto de los atributos de un intent se convierten
en opcionales.
Extras: información adicional contenida en un bundle. Puede ser usado para proporcionar
información adicional a un componente. Por ejemplo, para mandar un e-mail, se podría
añadir información extra aquí para el asunto del e-mail y el cuerpo del mensaje.
Módulo 1: Implementación de APPS interactivas y usables
7
Cuando un componente, como por ejemplo activity quiere invocar un intent, puede hacerlo
de dos formas:
Invocación implícita: donde la plataforma determina cuál componente es el más
adecuado para ejecutar el intent mediante un proceso de resolución de intent a partir de la
acción, datos y categoría.
Un ejemplo de invocación implícita para abrir el marcador de teléfono (sin hacer una
llamada) que proporciona Android, sería el siguiente, donde se crea un intent a partir de la acción
“Intent.ACTION_DIAL” y los datos en forma de objeto URI:
Al ejecutarlo, nos aparece directamente el marcador con el número de teléfono indicado:
Figura 1- Navegación entre activities.
Fuente: elaboración propia.
Invocación explícita: donde se especifica directamente en código una referencia a
componente (por ejemplo, a una clase activity o service) que procesará el intent.
Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:3142875423"));
startActivity(intent);
Módulo 1: Implementación de APPS interactivas y usables
8
Por ejemplo, para crear un intent y lanzar una activity explícitamente, se tiene que crear un
objeto de la clase intent con la sintaxis: intent (context/contexto, class/clase). Se lanzará invocando
al método “startActivity()” pasándole por argumento el intent creado:
El contexto se refiere a la página origen desde donde se pretende realizar la acción y la
pagina.class, página de destino a la cual se pretende navegar.
Ejemplo:
La activity menú es la página desde donde se invocará la página de Facebook .
Si además se desea pasar los datos por parámetro, se puede hacer a través de un objeto bundle:
Intent intent = new Intent(this, OtraActividad.class);
startActivity(intent);
Intent i=new Intent(contexto.this, pagina.class);
startActivity(i);
Intent i;
i=new Intent(Menu.this, faceboock.class);
startActivity(i);
Bundle bundle = new Bundle();
bundle.putString("nombreParametro", "valor");
Intent intent = new Intent(this, OtraActividad.class);
intent.putExtras(bundle);
startActivity(intent);
Módulo 1: Implementación de APPS interactivas y usables
9
Si se quieren leer desde la clase “OtraActividad” esos datos, se tendrá que hacer de la
siguiente forma:
Se pueden registrar tres componentes de Android como controladores intent: las activity,
los broadcast receiver y los services. Estas clases se pueden registrar en como destinos de intent con el
elemento <intent-filter> en el fichero “AndroidManifest.xml”:
Cada vez que se instala una aplicación en la plataforma Android se registran sus filtros
de intent. De esta forma, sabe asignar las solicitudes de intent entrantes al controlador
correspondiente. Las comparaciones que se realizan para asignar la solicitud son las siguientes:
La acción y la categoría deben de coincidir.
Si se especifica el tipo de datos, debe de coincidir también.
1.1.1. Enviar datos hacia otra actividad
Los objetos intent, además de navegar de una actividad a otra, se pueden utilizar para
comunicar y navegar entre dos o más actividades contenidas en una aplicación móvil. A este tipo
de información se le denomina extras y en su estructura está compuesta por un identificador y
un valor.
Bundle bundle = this.getIntent().getExtras();
String valorParametro = bundle.getString("nombreParametro");
<activity android:name=".HolaMundoActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
Módulo 1: Implementación de APPS interactivas y usables
10
Para iniciar una actividad, se debe anexar los datos al intent mediante el método
putExtra(). Este método tiene como objetivo enviar diferentes tipos de datos.
Para visualizar su utilización es necesario enviar la información mediante texto desde la
actividad de origen, para ser visualizada por otra actividad, el visor. La información enviada estará
representada por el nombre de la imagen que se va a visualizar, por ejemplo “imagen.jpg”. Para
ello se debe agregar un TextView en el cual se mostrará la información en el atributo text.
En la actividad main se declara la constante de tipo string, el cual representa el identificador
del dato extra para el objeto intent.
Ejemplo:
Es de gran relevancia contar con una cadena de texto única, de tal forma que no se cruce
con otra información. Por eso se elige el nombre del paquete del proyecto que se esté realizando,
con lo cual se asegura que no se repita. A manera de ejemplo, se mostrará la implementación del
método putExtra():
Recibir la información de la otra actividad
Para poder recibir la actividad proveniente de otra, se invoca el método getIntent(),
contenida en la clase activity, y posteriormente se obtiene el intent que inicializó la actividad.
Normalmente, todos las activity son inicializadas por un intent. De hecho, se puede obtener el
intent proveniente de la actividad principal inicializando el sistema.
public final static String VAR_EXTRA = "NOMBRE_PAQUETE.NOMBRE_ACTIVITY";
//Iniciando la actividad Visor
Intent intent = new Intent(this,Visor.class);
//Adjuntando la cadena de texto
intent.putExtra(NOMBRE_PAQUETE,"imagen.jpg");
//Ejecutando el intent
startActivity(intent);
Módulo 1: Implementación de APPS interactivas y usables
11
A partir del método onCreate() del visor, se obtiene el intent. Después de este, se extrae la cadena
de texto de la información enviada a través del método getStringExtra(), asignándosele al atributo
text del TextView: Ejemplo
1.1.2. Acciones descriptivas sobre acciones
Tabla 1
Acciones descriptivas
Constante Representativas Acción
ACTION_MAIN Empieza la actividad de una aplicación con el punto principal
de entrada
ACTION_VIEW Muestra información al usuario
// del TextView
nombre_imagen = (TextView)findViewById(R.id. nombre_imagen);
// Obtención de la instancia del Intent
Intent intent Obtención de la instancia = getIntent();
//Se extrae el extra de tipo cadena
String nombre = intent.getStringExtra(Main. VAR_EXTRA);
//Mostrando el valor del extra en el TextView
nombre_imagen.setText(nombre);
Módulo 1: Implementación de APPS interactivas y usables
12
Constante Representativas Acción
ACTION_ATTACH_DATA Indica que cierta información debe ser añadida en una parte
específica
ACTION_PICK Selecciona un ítem de un conjunto de datos y retorna en él
ACTION_DIAL Marca un número para iniciar una llamada
ACTION_CALL Realiza una llamada a un número especificado
ACTION_ANSWER Gestiona una llamada entrante
ACTION_SEARCH Realiza una búsqueda
ACTION_WEB_SEARCH Realiza una búsqueda web
Fuente: https://developer.android.com/reference/android/content/Intent.html
1.2. ListView
Las listas en Android son contenedores supremamente útiles para organizar información en
forma vertical y con la capacidad de usar scrolling (desplazamiento) para simplificar su
visualización. Esta técnica es muy popular en muchas aplicaciones, ya que permite mostrarle al
usuario un conjunto de datos de forma práctica y accesible.
La clase ListView representa una lista vertical en el API de Android con el mismo nombre.
Esta clase viene preparada para recibir los ítems que se desplegarán en la interfaz, facilitando al
programador la implementación de sus características y comportamientos. Si en algún momento
los ítems que contiene dificultan la visualización total en la actividad de la aplicación,
automáticamente implementará scrolling para que el usuario pueda desplegar los elementos
ocultos.
Estructuralmente un ListView contiene un view específico por cada fila. También se compone
de un ScrollView, el cual permite generar el desplazamiento vertical por si se agota la pantalla para
nuestros elementos (Gramlich, 2010)
Diseño de un ListView. Para la implementación de una lista, se crea la siguiente estructura:
Módulo 1: Implementación de APPS interactivas y usables
13
Como se puede ver, el elemento <ListView> es el equivalente de la clase ListView y ha
sido declarado como elemento raíz. Si se observan sus dimensiones, se le ha asignado
match_parent para que se ajuste al tamaño de la actividad (actividad basada en una lista)
(Gramlich, 2010).
El código anterior en el layout deberá generar una imagen como la siguiente:
Figura 2- Diseño de lista.
1.2.1. Implementación de una lista
Para diseñar una lista de datos para móviles se emplean algunos elementos que permiten
darle funcionalidad y facilitar su implementación:
<ListView
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/lista"/>
Módulo 1: Implementación de APPS interactivas y usables
14
1.2.2. Adaptador
Un adaptador es un objeto que comunica a un ListView los datos necesarios para crear
los registros de la lista, es decir, permite conectar la lista con el origen de información. Además,
provee la información y genera los views para cada elemento de la lista. En otras palabras, se
encarga de todo. Sin embargo, es la lista la que muestra la información final. Por otro lado, en
programación los adaptadores se representan por la clase Adapter (Revelo, 2014).
1.2.3. ListView-Adapter
Cuando se referencia un adaptador a un ListView inmediatamente se comienza un
proceso de comunicación interno para poblar la lista con los datos correspondientes. Dicha
comunicación se basa principalmente en los siguientes métodos del adaptador:
getCount(): retorna en la cantidad de elementos que tiene un adaptador. Con este valor
la lista ya puede establecer un límite para añadir filas.
getItem(): obtiene un elemento de la fuente de datos asignada al adaptador en una
posición establecida. Normalmente, la fuente de datos es un arreglo o lista de objetos.
getView(): retorna en el view elaborado e inflado de un elemento en una posición
especifica (Revelo, 2014).
Figura 3 - Estructura del diseño de una lista.
Fuente: http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
Módulo 1: Implementación de APPS interactivas y usables
15
Los siguientes son algunos de los parámetros para la construcción de la lista:
Declarar las instancias de la lista y el adaptador:
Fuente: http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
Obtener programáticamente una referencia de la lista:
Fuente: http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
Relacionando el adaptador con la lista:
Fuente: http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
El propósito de ellos es:
- Context context: representa el contexto de la aplicación. Se usa this para indicar que será
la actividad que se basa en la creación de la lista.
- Int resource: es el recurso de diseño o layout que representará cada fila de la lista. En este
caso, se usa un recurso del sistema llamado simple_list_item_1.xml. Este layout contiene
un solo TextView que contendrá el texto de cada fila.
- T[] objects: es la referencia del array de objetos de tipo T con los cuales se creará la lista.
Si desea, puede variar el constructor y usar una lista dinámica List<T>, en lugar del array.
Fuente: http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
ListView lista;
ArrayAdapter<String> adaptador;
...
lista = (ListView)findViewById(R.id.lista);
lista.setAdapter(adaptador);
Módulo 1: Implementación de APPS interactivas y usables
16
Código que construye los elementos para la lista
ListView listview1= (ListView)findViewById(R.id.lista1);
String listview_array[]={"Elemento 1", "Elemento 2", "Elemento 3", "Elemento 4"};
listview1.setAdapter( new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,
listview_array));
Figura 4 - Lista de elementos.
Fuente: elaboración propia.
1.3. WebView
El WebView es considerado el navegador interno de las aplicaciones Android, es decir, el
visor de páginas web nativo de Android. Por lo tanto, es muy propenso a recibir ataques desde
páginas web maliciosas. También, es una aplicación dispuesta por Android a la que tienen acceso
los desarrolladores a la hora de programar sus aplicaciones.
Hasta Android 5.0 Lollipop eran los fabricantes quienes se encargaban de lanzar estos
parches de seguridad con actualizaciones de sistema. Sin embargo, con las nuevas versiones de
Android esta tarea recayó en Google gracias a las actualizaciones del componente WebView a
través de Google Play, con lo que puede corregir los fallos de seguridad en menor tiempo y para
el mayor número de dispositivos.
1.3.1. Elementos para visualizar páginas en Android
WebView. Objeto que permite mostrar páginas web.
Módulo 1: Implementación de APPS interactivas y usables
17
loadUrl(). Función que permite cargar páginas web.
Figura 5 - Imágen de WebView
Fuente: http://www.elandroidelibre.com/2015/06/que-es-webview-y-por-que-tengo-que-actualizarlo.html
Implementando un WebView en Android.
Implementado un WebView en un layout.
Fuente: https://danielme.com/2012/05/19/android-webview-incrustar-un-navegador-en-nuestras-apps/
<?xml version="1.0" encoding="utf-8"?>
<WebView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/webview"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
/>
Módulo 1: Implementación de APPS interactivas y usables
18
1.3.2. Cargar una URL en Android
Ejemplo:
WebView myWebView = (WebView) findViewById(R.id.webview);
myWebView.loadUrl("http://www.example.com");
//Se debe crear la clase Externa Web View
import android.webkit.WebView;
import android.webkit.WebViewClient;
public class ViewClient extends WebViewClient {
public boolean shouldOverrideUrlLading(WebView v, String url){
v.loadUrl(url);
return true;
}
}
Módulo 1: Implementación de APPS interactivas y usables
19
Código Fuente propia
Estos códigos de javascript son de gran relevancia para la configuración de las páginas
invocadas desde una aplicación Android, porque permiten ajustarlas de acuerdo a la resolución
y tamaño del dispositivo.
sitio.setWebViewClient(new ViewClient());
sitio.getSettings().setJavaScriptEnabled(true);
sitio.getSettings().setLoadWithOverviewMode(true);
public class google extends Activity {
WebView sitio;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.google);
sitio = (WebView)findViewById(R.id.wvNavegador);
sitio.setWebViewClient(new ViewClient());
sitio.getSettings().setJavaScriptEnabled(true);
sitio.getSettings().setLoadWithOverviewMode(true);
sitio.getSettings().setUseWideViewPort(true);
sitio.loadUrl("http://www.google.es");
}
}
Módulo 1: Implementación de APPS interactivas y usables
20
sitio.getSettings().setUseWideViewPort(true);
1.4. Thread
En sistemas operativos thread (hilo), llamado hebra o subproceso, es la unidad de
procesamiento más pequeña que puede ser planificada por un sistema operativo. La creación de
un hilo es una característica que permite a una aplicación realizar varias tareas a la vez.
La diferencia básica entre un proceso de sistema operativo y un thread Java es que los hilos
corren dentro de la JVM, que es un proceso del sistema operativo y, por tanto, comparten todos
los recursos, incluida la memoria y las variables y objetos allí definidos. A este tipo de procesos
donde se comparte los recursos se les llama a veces procesos ligeros (lightweight process).
Según el Departamento de Informática de la Universidad de Valladolid, en la construcción
de aplicaciones para Android, los hilos son de gran utilidad para generar presentación y, en
ocasiones, para simular los procesos de carga de la aplicación. Desde el punto de vista de las
aplicaciones, los hilos son útiles porque permiten que el flujo del programa sea divido en dos o
más partes, cada una ocupándose de alguna tarea de forma independiente. Por ejemplo, un hilo
puede encargarse de la comunicación con el usuario, mientras que otros actúan en segundo
plano, realizando la transmisión de un fichero, accediendo a recursos del sistema (cargar sonidos,
leer ficheros), etc. De hecho, todos los programas con interface gráfico (AWT o swing, activity)
son multihilo porque los eventos y las rutinas de dibujado de las ventanas corren en un hilo
distinto al principal.
1.4.1. Construcción de hilos
La forma más directa para hacer un programa multihilo es extender la clase thread y
redefinir el método run(). Este método, de acuerdo al Departamento de Informática de la
Universidad de Valladolid, es invocado cuando se inicia el hilo (mediante una llamada al método
start() de la clase thread). El hilo se inicia con la llamada al método run() y termina cuando termina
este.
Ejemplo:
Módulo 1: Implementación de APPS interactivas y usables
21
Fuente: http://www.infor.uva.es/~fdiaz/sd/doc/hilos
public class ThreadEjemplo extends Thread {
public ThreadEjemplo(String str) {
super(str);
}
public void run() {
for (int i = 0; i < 10 ; i++)
System.out.println(i + " " + getName());
System.out.println("Termina thread " +
getName());
}
public static void main (String [] args) {
new ThreadEjemplo("Pepe").start();
new ThreadEjemplo("Juan").start();
System.out.println("Termina thread main");
}
}
Módulo 1: Implementación de APPS interactivas y usables
22
Figura 7- Imagen que muestra el proceso de carga mediante un hilo.
Fuente: http://www.hermosaprogramacion.com/wp-content/uploads/2014/12/android-progressbar-
landscape.png
1.4.2. Componentes de un hilo
Cuando se instancia la clase thread (o una subclase) se crea un nuevo thread que está en su
estado inicial ('New Thread' en el gráfico). En este estado es simplemente un objeto más. No
existe todavía el thread en ejecución. El único método que puede invocarse sobre él es el método
start().
Según el Departamento de Informática de la Universidad de Valladolid, cuando se invoca
el método start() sobre el hilo el sistema crea los recursos necesarios, lo planifica (le asigna
prioridad) y llama al método run(). En este momento el hilo está corriendo, se encuentra en el
estado ‘runable’. Si el método run() invoca internamente el método sleep() o wait() o el hilo tiene
que esperar por una operación de entrada/salida, entonces el hilo pasa al estado 'no runnable'
(no ejecutable) hasta que la condición de espera finalice. Durante este tiempo el sistema puede
ceder control a otros hilos activos. Por último, cuando el método run finaliza el hilo termina y
pasa a la situación dead (Muerto).
Este código visualiza en un tiempo determinado una imagen.
Módulo 1: Implementación de APPS interactivas y usables
23
Código - Elaboración propia
8.5 Toast .
public class AppWebSocialActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Thread logo = new Thread(){
public void run(){
try{
int tiempo=0;
while(tiempo<5000){
sleep(100);
tiempo=tiempo+100;
}
Intent i=new Intent("com.appwebsocial.es.Menu");
startActivity(i);
}
catch(InterruptedException e){
e.printStackTrace();
}finally{
finish();
}
}
};
logo.start();
}
}
Módulo 1: Implementación de APPS interactivas y usables
24
El toast es una clase que tiene como función visualizar mensajes sobrepuestos a la ventana
en un determinado período de tiempo, pero sin detener la aplicación. Se debe tener en cuenta
que este mensaje no permite interactuar con el usuario, es decir, no se pueden ingresar datos,
seleccionar botones ni obligar a que se cierre.
Un toast también es un mensaje en un pequeño pop-up, cuyo tamaño no excede el
contenido del mensaje. Este tipo de mensajes son muy útiles cuando se quiere mostrar cualquier
mensaje informativo, donde no se necesita la interacción del usuario. Por ejemplo, si se guardan
los datos de un usuario en la base de datos de una aplicación, se podría mostrar el mensaje
“Usuario guardado correctamente” en un toast.
Figura 9 - Representación de un mensaje.
Fuente: http://www.anpstudio.com/wp-content/uploads/2013/10/toast.png
1.4.3. Componentes de un toast
- makeText(). Este método toma tres parámetros: el contexto de la aplicación, el mensaje
de texto que queremos mostrar y la duración del toast.
- show(). Permite visualizar el mensaje.
1.4.4. Estructura de un toast
Toast.makeText(context, text, duration).show();
Módulo 1: Implementación de APPS interactivas y usables
25
1.4.5. Constantes de la clase toast
- LENGTH_SHORT. Duración corta.
- LENGTH_LONG. Duración larga.
Ejemplo:
Código completo que implementa u mensaje a través de un toast.
//actividad_main.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/toast_layout_root"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#C8C8C8"
android:gravity="center"
android:orientation="horizontal"
android:padding="10dp" >
<ImageView
Context context = getApplicationContext();
CharSequence text = "Hello toast!";
int duration = Toast.LENGTH_SHORT;
Toast toast = Toast.makeText(context, text, duration);
toast.show();
Módulo 1: Implementación de APPS interactivas y usables
26
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginRight="8dp"
android:src="@android:drawable/ic_dialog_info" />
<TextView
android:id="@+id/text_toast"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textColor="#FFF" />
</LinearLayout>
Fuente: https://developer.android.com/guide/topics/ui/notifiers/toasts.html
//MainActividad.java
Context context = getApplicationContext();
CharSequence text = "Hello toast!";
int duration = Toast.LENGTH_SHORT;
LayoutInflater inflater = getLayoutInflater();
View layout = inflater.inflate(R.layout.custom_toast,
(ViewGroup) findViewById(R.id.toast_layout_root));
TextView textToast = (TextView) layout.findViewById(R.id.text_toast);
textToast.setText(text);
Módulo 1: Implementación de APPS interactivas y usables
27
Toast toast = new Toast(context);
toast.setDuration(duration);
toast.setView(layout);
toast.show();
Fuente: https://developer.android.com/guide/topics/ui/notifiers/toasts.html
1.5. Manifest
Como lo explica el portal Tuprogramación.com, se encuentra situado en la raíz de las
aplicaciones de Android con el nombre AndroidManifest.xml y es el archivo de configuración
donde se pueden aplicar las configuraciones básicas de una app móvil. La configuración puede
ser realizada por medio de interfaz gráfica o por código. Sin embargo, es recomendable realizarla
por medio de la sintaxis debido a que es más sencillo y rápido hacerlo desde el propio xml. El
Android manifest está situado en la raíz de cada aplicación.
Módulo 1: Implementación de APPS interactivas y usables
28
2. Composición de una aplicación Android
Toda las aplicaciones que se construyan para para Android poseen una misma estructura
básica, que se compone del código fuente, archivos de recursos y vistas, librerías de código y el
Android manifest. Las siguientes definiciones han sido tomadas del portal Tuprogramación.com:
- Directorio SRC: se encuentra toda la lógica de aplicación, es decir, todas las clases
programadas en Java. Ahí se puede definir distintos paquetes, donde se puede dividir en
capas las reglas de negocio.
- Android Library: aquí se encuentran alojadas todas las librerías propias del SDK de
Android, dependiendo la versión elegida al crear el proyecto se tendrá una versión u otra.
- Directorios RES: en este paquete se encuentran todos los archivos con los recursos que
usan la aplicación: las imágenes, archivos de idiomas, estilos, etc.
2.1. Estructura de una aplicación Android
- Drawable. Carpeta donde se alojan todas las imágenes de la app. Se subdivide en
múltiples carpetas desde la versión 1.6, que contienen las imágenes en distintas
resoluciones y tamaños que se usarán dependiendo el dispositivo usado.
- Directorio layout. Aquí se encuentran las distintas “interfaces” de la aplicación, es decir,
los archivos xml asociadas a las activities.
- Values. Carpeta con los xml de contenido de la app. En ella se puede definir las
constantes de la aplicación, dando la posibilidad del multiidioma, estilos para los
componentes y demás configuraciones.
- Directorio bin. Aquí se encuentran todos los archivos generados por la propia app.
Como se sabe, Android usa la máquina virtual dalvik, primero se traduce a los típicos
archivos .class de java y posteriormente es traducido a los archivo .dex propios de
Android. También se encuentra el ejecutable de la aplicación "apk", que equivale a los
".exe" de Windows. Este es el archivo que se debe instalar en teléfono Android para
probar la aplicación.
Módulo 1: Implementación de APPS interactivas y usables
29
- Directorio gen. En esta carpeta está el archivo R.class, que contiene los identificadores
y los recursos usados por un proyecto: imágenes, layout, etc.
Si se abre el archivo R.java, se visualizarán los valores internos que se asignan a cada uno
de los identificadores de la aplicación.
- Directorio assests: carpeta donde se encuentran los archivos auxiliares de una
aplicación: imágenes, audios, vídeos. La diferencia con los que se encuentran en la
carpeta "RES" es que los archivos incluidos aquí no generarán un identificador dentro
del archivo R.class anteriormente descrito. Para usar estos archivos, en vez de
referenciarlos por un ID, habría que usar la ruta física como cualquier otro archivo
Directorio lib. Aquí irán las librerías externas importados que se necesiten.
Módulo 1: Implementación de APPS interactivas y usables
30
- Android Manifest: se considera el archivo básico de configuración de toda aplicación
Android. En él se definen todas las activities de la app y sus permisos.
Todas las activities de la app deben ser declaradas en esta sección, sino no se declaran
entonces la aplicación no funcionará. La actividad inicial de la aplicación debe ser declarada de
tipo "LAUNCHER":
//Estructura Código Manifest
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.appwebsocial.es"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="16" android:targetSdkVersion="16"/>
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<application
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="nombre.paquete"
android:versionCode="1"
android:versionName="1.0">
Módulo 1: Implementación de APPS interactivas y usables
31
android:icon="@drawable/logows"
android:label="@string/app_name"
android:debuggable="true" >
<activity
android:name=".AppWebSocialActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".Menu"
android:label="@string/app_name" >
<intent-filter>
<action android:name="com.appwebsocial.es.Menues" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
<activity android:name="google"></activity>
Módulo 1: Implementación de APPS interactivas y usables
32
<activity android:name="faceboock"></activity>
<activity android:name="twiter"></activity>
<activity android:name="skype"></activity>
<activity android:name="youtube"></activity>
</application>
</manifest>
//Vista de Diseño Manifest
Módulo 1: Implementación de APPS interactivas y usables
33
3. Glosario
Directorio bin: ahí se encuentran todos los archivos generados por la propia app.
Directorio layout: ahí se encuentran las distintas interfaces de la aplicación, es decir, los archivos
xml asociados a las activities.
Drawable: carpeta donde se alojan todas las imágenes de la app.
Layout: directorio donde se encuentran las distintas interfaces.
Manifest: archivo de configuración de Android.
Toast: objeto que tiene con función mostrar un mensaje.
SRC: directorio donde se alojan los archivos Android.
URL: Localizador de Recurso Universal.
Values: carpeta con los xml de contenido de la app.
4. Bibliografía
Ableson, F., & Sen, R. (2010). Android Guía para desarrolladores. Madrid: Anaya Multimedia.
Danieleme. (2012). Android WebView: incrustar un navegador en nuestras apps. Disponible en:
https://danielme.com/2012/05/19/android-webview-incrustar-un-navegador-en-nuestras-
apps/
El Android libre. (2015). Qué es WebView y por qué tengo que actualizarlo. Disponible en:
http://www.elandroidelibre.com/2015/06/que-es-webview-y-por-que-tengo-que-
actualizarlo.html
Gramlich, N. (2010). Android programming. Disponible en:
http://andbook.anddev.org/files/andbook.pdf
Haseman, C. (2008). Android Essentials. Estados Unidos: Apress.
Módulo 1: Implementación de APPS interactivas y usables
34
Hermosa Programación. (2014). Comunicar actividades a través de intents en Android,
Disponible en: http://www.hermosaprogramacion.com/2014/09/desarrollo-android-intents/
_______. (2014). Tutorial de listas y adaptadores en Android. Disponible en:
http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
Murphy, M.L. (2010). Android Programming Tutorials. Estados Unidos: CommonsWare.
Revelo, J. (2014). Tutorial de listas y adaptadores en Android. Disponible en:
http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/
Tu programación. (s.f.). Estructura de una aplicación Android. Disponible en:
https://developer.android.com/guide/topics/ui/notifiers/toasts.html
______. (s.f.). ¿Qué es el Android manifest? Disponible en:
http://www.tuprogramacion.com/glosario/que-es-el-android-manifest/
______. (s.f.). Estructura de una aplicación Android. Disponible en:
http://www.tuprogramacion.com/programacion/estructura-de-una-aplicacion-android/
Universidad de Valladolid. (s.f.). Sistemas distribuidos: hilos en Java. Disponible en:
http://www.infor.uva.es/~fdiaz/sd/doc/hilos