módulo 1: implementación de y usables

Módulo 1: Implementación de APPS interactivas y usables

1

Programación para dispositivos móviles II


Autor: Ing. Yamil Buenaño Palacios

Fecha de actualización: 11 de julio de 2016


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.


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.


4

Ideograma


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


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.


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);


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);


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);



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>


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



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);


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:


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"/>


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/

http://www.hermosaprogramacion.com/2014/10/android-listas-adaptadores/


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:


Obtener programáticamente una referencia de la lista:


Relacionando el adaptador con la lista:


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.


ListView lista;

ArrayAdapter<String> adaptador;

...

lista = (ListView)findViewById(R.id.lista);

lista.setAdapter(adaptador);


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.


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"

/>

https://danielme.com/2012/05/19/android-webview-incrustar-un-navegador-en-nuestras-apps/


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;

}

}


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");

}

}


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:


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");

}

}

http://www.infor.uva.es/~fdiaz/sd/doc/hilos


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.


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();

}

}


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();


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();

http://schemas.android.com/apk/res/android


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);


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.


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.


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.


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


<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


<manifest xmlns:android="http://schemas.android.com/apk/res/android"

package="nombre.paquete"

android:versionCode="1"

android:versionName="1.0">


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>


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


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.


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:


Murphy, M.L. (2010). Android Programming Tutorials. Estados Unidos: CommonsWare.

Revelo, J. (2014). Tutorial de listas y adaptadores en Android. Disponible en:


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

módulo 1: implementación de y usables

Documents