UNIDAD 2

Contenido
Android Views ..................................................................................................................................... 3
Vistas comunes................................................................................................................................ 3
Diagrama de clase del nivel superior del API View general ........................................................ 4
Utilizar ListView ............................................................................................................................... 8
Ejemplo Code ListView: ............................................................................................................... 8
Layout ................................................................................................................................................ 10
Layout Lineal ................................................................................................................................. 11
Table Layout .................................................................................................................................. 13
Layout Relativo .............................................................................................................................. 15
Absolute Layout ............................................................................................................................ 19
Frame Layout................................................................................................................................. 20
Menú ................................................................................................................................................. 21
Menús Contextuales ..................................................................................................................... 26
Notificaciones .................................................................................................................................... 31
Notificaciones de barra de estados ............................................................................................... 31
Definiendo Notificaciones de barra de estado.............................................................................. 32
Toast Notification .......................................................................................................................... 35
Alert Dialog.................................................................................................................................... 37
Progress Dialog .............................................................................................................................. 37
Android Views

Como se puede intuir, las vistas son las piezas básicas de la IU de una aplicación de Android. Las
activities, como vimos en la unidad anterior, contienen vistas y los objetos view representan
elementos de la pantalla y se encargan de interactuar con los usuarios a través de eventos.

Cualquier pantalla de Android contiene un árbol jerarquico de elementos View. Estas vistas
adoptan diferentes formas y tamaños. Muchas de las que habitualmente se necesitan las
proporciona la plataforma: elementos de texto básicos, elementos de entrada, imágenes, botones,
entre otros. Además se puede crear vistas compuestas y/o personalizadas en función de sus
necesidades. Las vistas se pueden incluir en una actividad (y por lo tanto en la pantalla)
directamente en el código o a través de recursos XML que se amplía en tiempo de ejecución.

Por defecto al crear una app android en eclipse se crea un file <main.xml> en res/layout.

Vistas comunes

Android proporciona un amplio conjunto de objetos View en el paquete android.view. Estos

objetos varían entre construcciones familiares como EditText, Spinner y TextView hasta
elementos más especializados como AnalogClock, Gallery, DatePicker, TimePicker y VideoView.

Como se deduce del diagrama de la siguiente hoja, el API View cuenta con diferentes clases.
ViewGroup es una sublclase especial de View relacionada con el diseño, como sucede con otros
elementos como TextView. En última instancia todo es una vista, incluso las clases de diseño (que
amplían de ViewGroup).

Como es de entenderse, todo lo que amplíe View tiene acceso a los métodos de la clase base.
Dichos métodos le permiten realizar importantes operaciones relacionadas con la IU, como definir
el fondo la anchura y altura mínimas, establecer el relleno, configurar y habilitar eventos (Por ej.
Los de click y enfoque), definir parámetros de diseño, entre otros.
Diagrama de clase del nivel superior del API View general
Ejemplos

Codigo TextView

<TextView android:id="@+id/nameText" android:layout_width="wrap_content"

android:layout_height="wrap_content" android:text="name" />

TextView tv = (TextView) findViewById(R.id.nameText);

tv.setText("name");

Ejemplo al crear un proyecto “hello world” en enclipse.

En la carpeta res/layouts podemos encontrar el file main.xml

<?xml version="1.0" encoding="utf-8"?>

<TextView
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/textview"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:text="@string/hello"/>

En este file <main> de extencion .XML se define la vista. El símbolo (@) indica al parser del xml
que lo que viene a continuación lo trate como un identificador de recurso. El atributo id identifica
a la vista dentro del árbol y permiterecuperarla desde desde la aplicación. El símbolo (+) indica
que el nombre que viene a continuación es un nombre nuevo y debe ser añadido a la clase de
recursos R.java. A continuación se muestra su código.

Las vistas heredan atributos sus clases base y definen sus propios atributos
 <?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="hello">Hello, Android! I am a string
resource!</string>
<string name="app_name">Hello, Android</string>
</resources>

Este código se encuentra en la carpeta res/resources, su función es únicamente como archivo de

recurso, es decir que se encargara de proporcionar un valor (en este caso del tipo string) cada vez
que sea invocado desde cualquier parte de la aplicación.

Método findViewById ()

Este método, permite acceder a la vista desde una actividad. Por ejemplo definiendo un botón:

Button btn = (Button) findViewById(R.id.acceptButton);

Subconjunto de métodos del API View de Android

Método Función
setBackgroundColor(int color) Establece el color de fondo.
setBackgroudDraweable(Draweable d) Establece la imagen de fondo.
setMinimumHeight(int minHeight) Establece la altura mínima.
setMinimunWidth(int minWidth) Establece la anchura mínima.
setPadding(int left, int right,int top, int bottom) Establece el relleno.
setClickeable(boolean c) Determina si se puede hacer clic o no en
un element.
setFocuseable(boolean f) Determina si el elemento recibe o no el
enfoque.
setOnClickListener(OnClickListener l) Establece un oyente que se desencadena
al producirse un evento de clic.
setOnFocusChangeListener(OnFocusChangeListener l) Establece un oyente que se desencadena
al producirse un evento de enfoque.
setLayoutParams(ViewGroup.LayoutParams l) Establece LayourParams (posición,
tamaño y otros).
Además de la clase base, cada subclase View suele añadir otros métodos para manipular su
estado, como sucede con TextView.

Método Función
setGravity(int gravity) Establece la alineación: superior, inferior,
izquierda, derecha, etc.
setHeight(int height) Define la dimensión de altura.
setWidth(int width) Define la dimensión de anchura.
setTypeFace(TypeFace face) Define el tipo de letra.
setText(CharSequence text) Define texto.

Mediante la combinación de los métodos de la clase base con los de subtipo, puede configurar el
diseño, relleno, enfoque, eventos, altura, anchura, colores y todo lo que necesite. Al emplear estos
métodos en el código o sus atributos homólogos del espacio de nombres Android: al definir vistas
en XML, puede manipular un elemento View.
ListView

ListView es un ViewGroup que crea una lista de ítems de forma scrollable. Esta lista de ítems es
automáticamente insertada dentro de la lista usando un ListAdapter.

Ejemplo Code ListView:

· Creamos un XML “list_item.xml” y lo guardamos en la carpeta res/layout/ .

Este contendrá el siguiente código:

<?xml version="1.0" encoding="utf-8"?>

<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:padding="10dp"
android:textSize="16sp" >
</TextView>

Con este código se define para todo ítem que este en la ListView su layout.

· Definiremos una clase Activity que extienda de listActivity.

public class HelloListView extends ListActivity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setListAdapter(new ArrayAdapter<String>(this, R.layout.list_item,

COUNTRIES));

ListView lv = getListView();
lv.setTextFilterEnabled(true);

lv.setOnItemClickListener(new OnItemClickListener() {
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {

Toast.makeText(getApplicationContext(), ((TextView)
view).getText(),
Toast.LENGTH_SHORT).show();
}
});
 · En este caso se va setear un array con el contenido de la lista (Nombre de países).

static final String[] COUNTRIES = new String[] {

"Afghanistan", "Albania", "Algeria", "American Samoa",
"Andorra","Angola", "Anguilla", "Antarctica", "Argentina"};

Al ejecutar la activity se mostrará de esta forma:

Layout

Los layouts son los elementos que permiten distribuir los componentes con una disposición
determinada.

Al desarrollar aplicaciones para Android se nos recomienda a definir las actividades, con sus
correspondientes elementos, en ficheros XML independientes del código. De esta manera se gana
en flexibilidad y claridad. Normalmente es muy tedioso escribir el código que construye la interfaz
gráfica instanciando cada uno de los objetos y agrupándolos de una manera específica. Además
cuesta bastante trabajo hacer cambios para probar diferentes disposiciones gráficas. Cuando se
utiliza un fichero externo para definir una interfaz se evitan estas molestias. El programador
simplemente describe cómo se agrupan los elementos de la actividad utilizando etiquetas XML de
un modo muy similar al utilizado en el desarrollo web. Entonces, las herramientas de desarrollo
interpretan este fichero y generan el código necesario.

Las ventajas de definir los componentes visuales en archivos XML son:

· Simplicidad y claridad en la descripción de las interfaces gráficas

· Es fácil y rápido cambiar la disposición gráfica
· Se separa el código de la aplicación de la representación gráfica de la interfaz
Evidentemente sigue siendo posible generar la interfaz de la manera tradicional, o bien esto será
una necesidad cuando la interfaz sea dinámica y los elementos se deban generar al vuelo durante
la ejecución del programa. Pero el nuevo enfoque en general resulta muy práctico y cómodo.

A la hora de diseñar interfaces para dispositivos móviles en general, hay que tener en cuenta que
el espacio de la pantalla es muy limitado, por lo que es fundamental seleccionar el tipo de Layout
que vamos a utilizar en el diseño.

Los distintos tipos de layout que podemos utilizar en nuestro desarrollo para una plataforma
Android son:

· Layout Lineal
· Table Layout
· Absolute Layout
· Relative Layout
· Frame Layout
Layout Lineal

Este layout apila, como su nombre lo indica, uno tras otro todos sus elementos hijos de forma
horizontal o vertical según se establezca su propiedad android:orientation.
Los elementos contenidos en un LinearLayout pueden establecer sus
propiedades android:layout_width y android:layout_height para determinar sus dimensiones
dentro del layout. Ademas tendremos otro parámetro con el que jugar, la
propiedad android:layout_weight. Esta propiedad nos va a permitir dar a los elementos
contenidos en el layout tome unas dimensiones proporcionales entre ellas. Esto es más dificil de
explicar que de comprender con un ejemplo. Si incluimos en un LinearLayout vertical dos cuadros
de texto (EditText) y a uno de ellos le establecemos un layout_weight=”1″ y al otro
un layout_weight=”2″ conseguiremos como efecto que toda la superficie del layout quede
ocupada por los dos cuadros de texto y que además el segundo sea el doble (relación entre sus
propiedades weight) de alto que el primero.

Para ponerlo de forma vertical, en la propiedad android:orientation hay que indicarle el valor
“vertical”.
Se visualizará de la siguiente forma:

Si lo que queremos es darle una orientación horizontal, el valor de la propiedad será “horizontal”.
Se visualizará de la siguiente forma:

Table Layout

Un TableLayout permite distribuir sus elementos hijos de forma tabular, definiendo las filas y
columnas necesarias, y la posición de cada componente dentro de la tabla.
La estructura de la tabla se define de forma similar a como se hace en HTML, es decir, indicando
las filas que compondrán la tabla (objetos TableRow), y dentro de cada fila las columnas
necesarias, con la salvedad de que no existe ningún objeto especial para definir una columna (algo
así como unTableColumn) sino que directamente insertaremos los controles necesarios dentro
del TableRow y cada componente insertado (que puede ser un control sencillo o incluso
otro ViewGroup) corresponderá a una columna de la tabla. De esta forma, el número final de filas
de la tabla se corresponderá con el número de elementos TableRowinsertados, y el número total
de columnas quedará determinado por el número de componentes de la fila que más
componentes contenga.
Por norma general, el ancho de cada columna se corresponderá con el ancho del mayor
componente de dicha columna, pero existen una serie de propiedades que nos ayudarán a
modificar este comportamiento:
· android:stretchColumns. Indicará las columnas que pueden expandir para absorver el espacio libre
dejado por las demás columnas a la derecha de la pantalla.
· android:shrinkColumns. Indicará las columnas que se pueden contraer para dejar espacio al resto
de columnas que se puedan salir por la derecha de la palntalla.
· android:collapseColumns. Indicará las columnas de la tabla que se quieren ocultar
completamente.
Todas estas propiedades del TableLayout pueden recibir una lista de índices de columnas
separados por comas (ejemplo: android:stretchColumns=”1,2,3″) o un asterisco para indicar que
debe aplicar a todas las columnas (ejemplo: android:stretchColumns=”*”).
Otra característica importante es la posibilidad de que una celda determinada pueda ocupar el
espacio de varias columnas de la tabla (análogo al atributo colspan de HTML). Esto se indicará
mediante la propiedad android:layout_span del componente concreto que deberá tomar dicho
espacio.

Ejemplo:
Se visualizará de la siguiente manera:

Layout Relativo

Este es el layout más flexibles de todos. El RelativeLayout permite especificar la posición de cada
elemento de forma relativa a su elemento padre o a cualquier otro elemento incluido en el propio
layout. De esta forma, al incluir un nuevo elemento X podremos indicar por ejemplo que debe
colocarse debajo del elemento Y alineado a la derecha del layout padre. Veamos esto en el
ejemplo siguiente:
 En el ejemplo, el botón BtnAceptar se colocará debajo del cuadro de
texto TxtNombre(android:layout_below=”@id/TxtNombre”) y alineado a la derecha del layout
padre (android:layout_alignParentRight=”true”)

Al igual que estas tres propiedades, en un RelativeLayout tendremos un sinfín de propiedades para
colocar cada control justo donde queramos.

Veamos las principales (sus nombres explican perfectamente la funciona que realizan):

Posición relativa a otro control:

· android:layout_above.
· android:layout_below.
· android:layout_toLeftOf.
· android:layout_toRightOf.
· android:layout_alignLeft.
· android:layout_alignRight.
· android:layout_alignTop.
· android:layout_alignBottom.
· android:layout_alignBaseline.

Posición relativa al layout padre:

· android:layout_alignParentLeft.
· android:layout_alignParentRight.
· android:layout_alignParentTop.
· android:layout_alignParentBottom.
· android:layout_centerHorizontal.
· android:layout_centerVertical.
· android:layout_centerInParent.

Opciones de margen (también disponibles para el resto de layouts):

· android:layout_margin.
· android:layout_marginBottom.
· android:layout_marginTop.
· android:layout_marginLeft.
· android:layout_marginRight.

Opciones de espaciado o padding (también disponibles para el resto de layouts):

· android:padding.
· android:paddingBottom.
· android:paddingTop.
· android:paddingLeft.
· android:paddingRight.
Ejemplo:

Se visualizará de la siguiente forma:

Absolute Layout

Es una capa donde se utilizan coordenadas X e Y para indicarle donde colocar los elementos
dentro del diseño. En cada elemento del código se le indicará el valor de X y de Y.

Ejemplo:

Se visualizará de la siguiente manera:

Frame Layout

Éste es el más simple de todos los layouts de Android. Un FrameLayout coloca todos sus controles
hijos alineados con su esquina superior izquierda, de forma que cada control quedará oculto por el
control siguiente (a menos que éste último tenga transparencia). Por ello, suele utilizarse para
mostrar un único control en su interior, a modo de contenedor (placeholder) sencillo para un sólo
elemento sustituible, por ejemplo una imagen.
Los componentes incluidos en un FrameLayout podrán establecer sus propiedades
android:layout_width y android:layout_height, que podrán tomar los valores “fill_parent” (para
que el control hijo tome la dimensión de su layout contenedor) o “wrap_content” (para que el
control hijo tome la dimensión de su contenido).

Ejemplo:

Se visualizará de la siguiente forma:

 Menú

En Android podemos encontrar 3 tipos diferentes de menús:

· Menús Principales. Los más habituales, aparecen en la zona inferior de la pantalla al pulsar el
botón ‘menu’ del teléfono.
· Submenús. Son menús secundarios que se pueden mostrar al pulsar sobre una opción de un menú
principal.
· Menús Contextuales. Útiles en muchas ocasiones, aparecen al realizar una pulsación larga sobre
algún elemento de la pantalla.

Vamos a tener dos alternativas a la hora de mostrar un menú en nuestra aplicación Android. La
primera de ellas mediante la definición del menú en un archivo XML, y la segunda creando el
menú directamente mediante código.

Veamos en primer lugar cómo crear un menú a partir de su definición en XML. Los ficheros XML de
menú se deben colocar en la carpeta “res\menu” de nuestro proyecto y tendrán una estructura
análoga a la del siguiente ejemplo:

Como se puede observar, la estructura básica de estos archivos XML es muy sencilla. Tendremos
un elemento principal <menu> que contendrá una serie de elementos <item> que se
corresponderán con las distintas opciones a mostrar en el menú. Estos elementos <item> tendrán
a su vez varias propiedades básicas, como su ID (android:id), su texto (android:title) o su icono
(android:icon). Los iconos utilizados deberán estar por supuesto en las carpetas “res\drawable-…”
de nuestro proyecto.
Una vez definido el menú en el fichero XML, tendremos que implementar el evento
onCreateOptionsMenu() de la actividad que queremos que lo muestre. Primero obtendremos una
referencia al inflater mediante el método getMenuInflater() y posteriormente generaremos la
estructura del menú llamando a su método inflate() pasándole como parámetro el ID del menu
definido en XML, que en nuestro caso será R.menu.menu_principal. Por último devolveremos el
valor true para confirmar que debe mostrarse el menú.

El resultado del menú se verá reflejado de la siguiente manera:

Este mismo menú también lo podríamos crear directamente mediante código, también desde el
evento onCreateOptionsMenu().Para añadir cada opción del menú podemos utilizar el
método add() sobre el objeto de tipo Menu que nos llega como parámetro del evento. Este
método recibe 4 parámetros: ID del grupo asociado a la opción, un ID único para la opción (que
declararemos como constantes de la clase), el orden de la opción (utilizaremos Menu.NONE) y el
texto de la opción. Por otra aprte, el icono de cada opción lo estableceremos mediante el
método setIcon() pasándole el ID del recurso. Veamos cómo quedaría el código utilizando esta
alternativa, que generaría un menú exactamente igual al del ejemplo anterior:

Construido el menú, la implementación de cada una de las opciones se incluirá en el evento

onOptionsItemSelected() de la actividad que mostrará el menú. Este evento recibe como
parámetro el item de menú que ha sido pulsado por el usuario, cuyo ID podemos recuperar con el
método getItemId(). Según este ID podremos saber qué opción ha sido pulsada y ejecutar unas
acciones u otras. En nuestro caso de ejemplo, lo único que haremos será modificar el texto de una
etiqueta (lblMensaje) colocada en la pantalla principal de la aplicación.

Con todo esto conseguimos un menú completamente funcional. Si probamos este ejemplo con el
emulador comprobaremos cómo al pulsar el botón de ‘menu‘del teléfono aparece el menú que
hemos definido y que al pulsar cada opción se muestra el mensaje de ejemplo.
Pasemos ahora a comentar los submenús. Un submenú no es más que un menú secundario que se
muestra al pulsar una opción determinada de un menú principal. Los submenús en Android se
muestran en forma de lista emergente, cuyo título contiene el texto de la opción elegida en el
menú principal. Como ejemplo, vamos a añadir un submenú a la Opción 3 del ejemplo anterior, al
que añadiremos dos nuevas opciones secundarias. Para ello, bastará con insertar en el XML de
menú un nuevo elemento <menu> dentro del item correspondiente a la opción 3. De esta forma,
el XML quedaría ahora como sigue:

Si pulsamos la opción 3 nos aparecerá el correspondiente submenú con las dos nuevas opciones
añadidas. Lo vemos en la siguiente imagen:
Comprobamos como efectivamente aparecen las dos nuevas opciones en la lista emergente, y que
el título de la lista se corresponde con el texto de la opción elegida en el menú principal
(“Opcion3“).
Para conseguir esto mismo mediante código procederíamos de forma similar a la anterior, con la
única diferencia de que la opción de menú 3 la añadiremos utilizando el método addSubMenu() en
vez de add(), y guardando una referencia al submenu. Sobre el submenú añadido insertaremos las
dos nuevas opciones utilizando una vez más el método add(). Vemos cómo quedaría:

En cuanto a la implementación de estas opciones de submenú no habría diferencia con todo lo

comentado anteriormente ya que también se tratan desde el evento onOptionsItemSelected(),
identificándolas por su ID.
Menús Contextuales

También existe otro tipo de menús que nos pueden ser muy útiles en determinados contextos: los
menús contextuales. Este tipo de menú siempre va asociado a un control concreto de la pantalla y
se muestra al realizar una pulsación larga sobre éste. Suele mostrar opciones específicas
disponibles únicamente para el elemento pulsado. Por ejemplo, en un control de tipo lista
podríamos tener un menú contextual que apareciera al pulsar sobre un elemento concreto de la
lista y que permitiera editar su texto o eliminarlo de la colección.

La creación y utilización de este tipo de menús es muy parecida a lo que ya vimos para los menús y
submenús básicos, pero presentan algunas particularidades muy interesantes para tratar.

Vamos a partir del ejemplo del artículo anterior, al que vamos a añadir en primer lugar un menú
contextual que aparezca al pulsar sobre la etiqueta de texto que mostrábamos en la ventana
principal de la aplicación. Para ello, lo primero que vamos a hacer es indicar en el
método onCreate() de nuestra actividad principal que la etiqueta tendrá asociado un menú
contextual. Esto lo conseguimos con una llamada a registerForContextMenu():

A continuación, igual que hacíamos con onCreateOptionsMenu() para los menús básicos, vamos a
sobreescribir en nuestra actividad el evento encargado de construir los menús contextuales
asociados a los diferentes controles de la aplicación. En este caso el evento se llama
onCreateContextMenu(), y a diferencia de onCreateOptionsMenu() éste se llama cada vez que se
necesita mostrar un menú contextual, y no una sola vez al inicio de la aplicación. En este evento
actuaremos igual que para los ménus básicos, “inflando” el menú XML que hayamos creado con
las distintas opciones, o creando a mano el menú mediante el método add(). En nuestro ejemplo
hemos definido un menú en XML llamado “menu_ctx_etiqueta.xml“:
Por su parte el evento onCreateContextMenu() quedaría de la siguiente forma:

Por último, para implementar las acciones a realizar tras pulsar una opción determinada del menú
contextual vamos a implementar el evento onContextItemSelected() de forma análoga a cómo
hacíamos con onOptionsItemSelected() para los menús básicos:

Con esto, ya tendríamos listo nuestro menú contextual para la etiqueta de texto de la actividad
principal, y como se puede observar todo es prácticamente análogo a cómo construimos los
menús y submenús básicos anteriormente.

Ahora vamos con algunas particularidades. Los menús contextuales se utilizan a menudo con
controles de tipo lista, lo que añade algunos detalles que conviene mencionar. Para ello vamos a
añadir a nuestro ejemplo una lista con varios datos de muestra y vamos a asociarle un nuevo
menú contextual. Modificaremos el layout XML de la ventana principal para añadir el
control ListView y modificaremos el método onCreate() para obtener la referencia al control,
insertar varios datos de ejemplo, y asociarle un menú contextual:

Como en el caso anterior, vamos a definir en XML otro menú para asociarlo a los
elementos de la lista, lo llamaremos “menu_ctx_lista“:

Como siguiente paso, y dado que vamos a tener varios menús contextuales en la misma actividad,
necesitaremos modificar el evento onCreateContextMenu() para que se construya un menú
distinto dependiendo del control asociado. Esto lo haremos obteniendo el ID del control al que se
va a asociar el menú contextual, que se recibe en forma de parámetro (View v) en el evento
onCreateContextMenu(). Utilizaremos para ello una llamada al método getId() de dicho
parámetro:
Vemos cómo en el caso del menú para el control lista hemos ido además un poco más allá, y
hemos personalizado el título del menú contextual, mediante setHeaderTitle(), para que muestre
el texto del elemento seleccionado en la lista. Para hacer esto nos hace falta saber la posición en la
lista del elemento seleccionado, algo que podemos conseguir haciendo uso del último parámetro
recibido en el evento onCreateContextMenu(), llamado menuInfo. Este parámetro contiene
información adicional del control que se ha pulsado para mostrar el menú contextual, y en el caso
particular del control ListView contiene la posición del elemento concreto de la lista que se ha
pulsado. Para obtenerlo, convertimos el parámetro menuInfo a un objeto de
tipo AdapterContextMenuInfo y accedemos a su atributo position tal como vemos en el código
anterior.
La respuesta a este nuevo menú se realizará desde el mismo evento que el anterior, todo dentro
de onContextItemSelected(). Por tanto, incluyendo las opciones del nuevo menú contextual para
la lista el código nos quedaría de la siguiente forma:
Como vemos, aquí también utilizamos la información del objeto AdapterContextMenuInfo para
saber qué elemento de la lista se ha pulsado, con la única diferencia de que en esta ocasión lo
obtenemos mediante una llamada al método getMenuInfo() de la opción de menú (MenuItem)
recibida como parámetro.
El menú contextual se vera de la siguiente forma:
Notificaciones

En varias ocasiones se requiere notificar al usuario de los eventos que ocurren en las aplicaciones.
Estos eventos pueden requerir una respuesta del usuario o no. Por ejemplo:

· Cuando un evento tal que guarda un archivo se completa, podría notificar al usuario que
esta acción se realizó correctamente.
· Si la aplicación está corriendo en background y se necesita la atención del usuario, la
aplicación deberá crear una notificación que permita obtener una respuesta del usuario.

Notificaciones de barra de estados

La notificación de barra de estados añade un icono a la barra de estado del sistema y un mensaje
de notificación en la ventana de notificaciones. Cuando el usuario selecciona la notificación,
Android dispara la intención que se define por la notificación (por lo general desencadena una
activity). Las notificaciones también pueden ser configuradas para alertar al usuario con un sonido,
una vibración y / o luces intermitentes en el dispositivo.

La notificación barra de estados debe ser utilizada para cualquier caso en que un servicio de
fondo tiene que advertir al usuario acerca de un evento que requiere una respuesta. Un servicio
en segundo plano nunca debe poner en marcha una actividad por cuenta propia con el fin de la
interacción del usuario. Los servicios en lugar deberían crear una notificación de barra de
estado que pondrá en marcha la actividad cuando sea seleccionado por el usuario.

La siguiente imagen muestra la barra de estado con un icono de notificación en el lado izquierdo.
A continuación se muestra un mensaje de notificación en la ventana de notificaciones.

Definiendo Notificaciones de barra de estado

Una Activity o Service puede inicializar una notificación de barra de estado. Porque una activity
solo puede ejecutar acciones solo cuando está en primer plano y posee el foco. Correctamente
deberá crear una notificación de barra de estado desde un servicio. De esta forma la notificación
puede ser creada en background. Mientras un usuario está usando otra aplicacion o mientras el
dispositivo no esta active. Para crear una notificación, se deberá usar dos clases: Noification y
Notification Manager.

Se debe usar una instancia de la clase Notification para definer las propiedades de su notificación
de barra de de estado, tales como el icono de barra de estado, el mensaje de notificación y otras
características extra como puede ser el sonido de reproducción. NotificationManager es un
servicio del sistema Android que ejecuta y administra todas las notificaciones de barra de estado.
Esta clase no se instancia directamente, esta deberá ser capturada con el metodo
getSystemService() para poder referenciarla. Por ultimo, cuando es el momento de notificar al
usuario solo basta con ejecutar el metodo notify().
Ejemplo

1. Tomar la referencia de la clase NotificationManager

String ns = Context.NOTIFICATION_SERVICE;
NotificationManager mNotificationManager = (NotificationManager)
getSystemService(ns);

2. Instanciar Notification

int icon = R.drawable.notification_icon;

CharSequence tickerText = "Hello";
long when = System.currentTimeMillis();

Notification notification = new Notification(icon, tickerText, when);

3. Definiendo una notification y un PenndingIntent

Context context = getApplicationContext();

CharSequence contentTitle = "My notification";
CharSequence contentText = "Hello World!";
Intent notificationIntent = new Intent(this, MyClass.class);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
notificationIntent, 0);

notification.setLatestEventInfo(context, contentTitle, contentText,

contentIntent);

4. Pasando la notificación al NotifiationManager

private static final int HELLO_ID = 1;

mNotificationManager.notify(HELLO_ID, notification);

A continuación se presenta un ejemplo para agregar un conjunto de intenciones al lanzar una

notificación.
 static Intent[] makeMessageIntentStack(Context context, CharSequence
from,
CharSequence msg) {

Intent[] intents = new Intent[4];

intents[0] = Intent.makeRestartActivityTask(new
ComponentName(context,com.example.android.apis.ApiDemos.class));

intents[1] = new
Intent(context,com.example.android.apis.ApiDemos.class);
intents[1].putExtra("com.example.android.apis.Path", "App");

intents[2] = new
Intent(context,com.example.android.apis.ApiDemos.class);
intents[2].putExtra("com.example.android.apis.Path",
“App/Notification");

intents[3] = new Intent(context, IncomingMessageView.class);

intents[3].putExtra(IncomingMessageView.KEY_FROM, from);
intents[3].putExtra(IncomingMessageView.KEY_MESSAGE, msg);

return intents;
}

Para la creación del pending item con este método sería:

PendingIntent contentIntent = PendingIntent.getActivities(this, 0,

makeMessageIntentStack(this, from, message),
PendingIntent.FLAG_CANCEL_CURRENT);
Toast Notification

Este tipo de notificación es un mensaje que aparece en la superficie de la ventana. Solo ocupa el
espacio requerido por el mensaje, y la actividad actual del usuario permanece visible. La
notificación desaparece automáticamente sin interacción del usuario.

En el siguiente ejemplo se muestra una Toast Notification en una app de alarma

Para crear una Toast Notification, primero, hay que instanciar un objeto Toast con un método
makeText() . Este método toma tres parámetros: el contexto de la app, el texto del mensaje, y la
duración en pantalla. Para poder mostrar la notificación solo se debe utilizar el método show().

Context context = getApplicationContext();

CharSequence text = "Hello toast!";
int duration = Toast.LENGTH_SHORT;

Toast toast = Toast.makeText(context, text, duration);

toast.show();

Se podría haber seteado la ubicación en pantalla de la siguiente manera:

toast.setGravity(Gravity.TOP|Gravity.LEFT, 0, 0);

Si con un simple texto no es suficiente también es posible crear un custom Layout. Para esto se
debe definir una vista en XML o en su código de aplicación, para luego ser consumida por el
método setView(View).
Ejemplo definición de la vista en XML:

<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/example_toast_layout "
android:orientation="horizontal"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:padding="10dp"
android:background="#DAAA"
>
<ImageView android:id="@+id/image"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:layout_marginRight="10dp"
/>
<TextView android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:textColor="#FFF"
/>
</LinearLayout>

Acontinuación se asocia la vista creada al Toast:

LayoutInflater inflater = getLayoutInflater();

View layout = inflater.inflate(R.layout.toast_layout,
(ViewGroup) findViewById(R.id.
example_toast_layout));

ImageView image = (ImageView) layout.findViewById(R.id.image);

image.setImageResource(R.drawable.android);
TextView text = (TextView) layout.findViewById(R.id.text);
text.setText("Hello! This is a custom toast!");

Toast toast = new Toast(getApplicationContext());

toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
toast.setDuration(Toast.LENGTH_LONG);
toast.setView(layout);
toast.show();

También se suelen mencionar como un tipo de notificaciones algunos tipos de dialogs, por
ejemplo el processing dialog que únicamente es lanzado desde una activity.
Alert Dialog

Alert Dialog es una subclase de Dilog que permite mostrar uno, dos o tres botones. Tambien
permitiendo mostrar solo el texto usando el método setMessage(). Si se quiere mostrar de otra
forma debe utilizar un Layout “Custom”.

Ejemplo:

AlertDialog.Builder builder = new AlertDialog.Builder(this);

builder.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener()
{
public void onClick(DialogInterface dialog, int id) {
MyActivity.this.finish();
}
})
.setNegativeButton("No", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
AlertDialog alert = builder.create();

Se mostraría:

Progress Dialog

Este tipo de Dialog, es una extención del recién mencionado AlertDialog y permite mostrar una
animación de progreso en forma de rueda, por ejemplo en una descarga. A este dialog se le puede
agregar un botón, por ejemplo que detenga dicha descarga.
Para abrir un progress dialog se debe llamar al método “ProgresDialog.show()”.

ProgressDialog dialog = ProgressDialog.show(MyActivity.this, "",

"Loading. Please wait...", true);

Se mostraría: