«

»

sep 05 2012

Notificaciones: Método tradicional, Notification Builder y Jelly Bean

Las notificaciones de Android son una parte central del sistema operativo, y si me apretáis diré que para mi son la más importante. Cuando uso otros teléfonos me doy cuenta de lo mucho que echo de menos tener esa bandeja desplegable. Existen desde la primera versión, y con el tiempo han ido sufriendo algunos cambios.

 

 

En Honeycomb se introdujeron nuevas funciones y una forma más fácil de crear notificaciones con el Notification Builder. Con Android 4.1 Jelly Bean se vuelven a introducir novedades, concretamente la posibilidad de crear notificaciones expandidas más grandes con 3 estilos predefinidos, la opción de añadir hasta 3 botones a la notificación, y un sistema de prioridades para ordenar las notificaciones en la bandeja.

En este tutorial vamos a ver cómo crear y lanzar estas notificaciones. Incluyendo las nuevas de Jelly Bean. Aunque se pueden personalizar hasta cierto punto con layouts propios, en este tutorial nos centraremos en las que se crean por defecto.  Para cada ejemplo pondré un método que devuelve un objeto tipo Notification que es común para todas las versiones, y al final veremos cómo lanzar esa notificación obtenida en cualquier método.

 

Important!

Actualización: Unas horas después de escribir este tutorial, el todopoderoso Jake Wharton (autor de ActionBarSherlock entre otras) ha publicado una librería de compatibilidad para las notificaciones. Esto nos permite usar un único Builder para todas las versiones desde 1.6 a 4.1 (con todas los extras de ésta). Podéis echarle un vistazo aquí.

 

Vieja escuela

Para tener claros todos los conceptos, veamos primero cómo se creaban las notificaciones antes de Honeycomb. Básicamente creamos un nuevo objetos de tipo Notification y le ponemos los datos con el método setLatestEventInfo().
 

private Notification getOldNotification() {
		Notification notif = new Notification(R.drawable.ic_launcher, "Optional ticker text", System.currentTimeMillis());
		notif.setLatestEventInfo(mContext, "Old title", "Old notification content text", PendingIntent.getActivity(mContext, 0, new Intent(), 0));
		return notif;
	}

 

Como veis es muy sencillo. Creamos un objeto Notification con su constructor pasándole el icono que mostrará en la barra de notificaciones, el texto opcional que se mostrará momentáneamente en la barra (se le puede pasar null para que no lo haga) y la hora actual en milisegundos. El setLatestEventInfo() define lo que mostrará la notificación en la bandeja desplegada; le pasamos el contexto, el título, un texto y un PendingIntent para definir lo que hará al pulsarse sobre ella. Si quisiéramos darle una apariencia personalizada tendremos que modificar las propiedades contentView y contentIntent en vez de usar el método setLatestEventInfo(), pero eso no lo veremos en el tutorial. Éste es el aspecto que tendrá la notificación generada con el método anterior en un teléfono con Android 2.3 y en otro con 4.1.

 

 

No es difícil, pero podría ser mejor.

 

El Notification.Builder es tu amigo

Como dije al principio, desde Honeycomb (API 11) tenemos disponible la clase Notification.Builder para facilitar la tarea de crear notificaciones. Se crea con una línea.

 

Notification.Builder builder = new Notification.Builder(mContext);

 

Y se usa como en el siguiente ejemplo:

 

private Notification getDefaultNotification(Notification.Builder builder) {
		builder
			.setSmallIcon(R.drawable.ic_launcher)
			.setTicker("Optional ticker")
			.setWhen(System.currentTimeMillis())
			.setContentTitle("Default notification")
			.setContentText("Lorem ipsum dolor sit amet, consectetur adipiscing elit.")
			.setContentInfo("Info")
			.setLargeIcon(bitmapIcon)
			.setContentIntent(doIntent)
			.setDeleteIntent(deleteIntent);

			//return builder.build(); //A partir de Jelly Bean se usa éste método-
			return builder.getNotification();
	}

 

Más claro y directo, ¿verdad? Los 3 primeros métodos corresponden a los parámetros del constructor que vimos antes. Los setContentTitle(), setContentText() y setContentIntent() son equivalentes a los del setLatestEventInfo(). Pero además el Builder permite usar otras funciones nuevas, como el setDeleteIntent() que lanza un PendingIntent cuando el usuario quita la notificación, o el setLargeIcon() que coloca una imagen más grande a la izquierda de la notificación (como la foto del contacto que nos ha enviado un email).

 

 

Esas son las principales, pero tiene más funciones como colocar una barra de progreso o usar una vista diferente para el Ticker ‘grande’ que sale en los Tablets. Os recomiendo que echéis un ojo a la documentación. Por último generamos la notificación con getNotification(), o con build() si estamos en API 16 o superior.

 

¡Jelly Bean!

Y como en Androcode estamos puestos al día, veamos también cómo usar las nuevas notificaciones y estar listos para cuando nuestros usuarios empiecen a actualizarse. Aunque al igual que con las notificaciones tradicionales es posible crear layouts propios, nosotros nos centraremos en los 3 estilos que vienen de serie. Recordad que estos estilos se expanden y contraen, por lo que tenemos que definir unos datos para la notificación normal y otros para la grande. Además, por defecto sólo aparecerá expandida la primera notificación de la bandeja, el resto estarán contraídas y el usuario podrá abrirlas manualmente con un gesto.

 

BigText, mucho texto

El primer estilo de notificación se usa para mostrar una mayor cantidad de texto gracias a la clase Notification.BigTextStyle. Se usa (al igual que los otros 2 estilos) cogiendo un Builder creado como en el apartado anterior, y pasándolo por su clase para aplicarle algunos métodos opcionales. Queda más claro con un ejemplo:

 

private Notification getBigTextStyle(Notification.Builder builder) {
		builder
				.setContentTitle("Reduced BigText title")
				.setContentText("Reduced content")
				.setContentInfo("Info")
				.setSmallIcon(R.drawable.ic_launcher)
				.setLargeIcon(bitmapIcon);

		return new Notification.BigTextStyle(builder)
				.bigText("Looooooooooooooong teeeeeeeeeext.... (and more, and more, and more)")
				.setBigContentTitle("Expanded BigText title")
				.setSummaryText("Summary text")
				.build();
	}

 

Fácil, ¿a que sí? Los métodos de la primera parte son los mismos de antes, y corresponden a la forma contraída de la notificación. En la segunda parte establecemos el texto largo, como puede ser el contenido de un correo electrónico o de un SMS, el título que llevará en su forma expandida si queremos que sea diferente, y un resumen opcional que se mostrará en 1 línea al final del texto. En la captura podéis ver un ejemplo de cómo quedaría la misma notificación expandida y contraída.

 

 

Lo mejor es que en nuestra aplicación no tenemos por qué usar 2 métodos distintos según la versión. Podemos crear el builder de la notificación normal, y si estamos en la API 16 lo pasamos por el segundo proceso.

 

BigPicture, una imagen vale más que mil palabras

Si la notificación es relativa a una imagen también podemos usar una notificación expandida para mostrar dicha imagen en la bandeja gracias a Notification.BigPictureStyle. Su uso es casi idéntico al anterior, cambiando la clase y métodos de la segunda parte.

 

private Notification getBigPictureStyle(Notification.Builder builder) {
		// In this case the icon in reduced mode will be the same as the picture
		// when expanded.
		// And when expanded, the icon will be another one.
		Bitmap large = bitmapBigImage;
		Bitmap notSoLarge = bitmapIcon;
		builder
				.setContentTitle("Reduced BigPicture title")
				.setContentText("Reduced content")
				.setContentInfo("Info")
				.setSmallIcon(R.drawable.ic_launcher)
				.setLargeIcon(large);

		return new Notification.BigPictureStyle(builder)
				.bigPicture(large)
				.bigLargeIcon(notSoLarge)
				.setBigContentTitle("Expanded BigPicture title")
				.setSummaryText("Summary text")
				.build();
	}

 

En este caso en vez de colocarle un texto le ponemos la imagen grande que queremos mostrar con bigPicture() y si queremos que la imagen “pequeña” a la izquierda de la notificación sea distinta en la forma expandida también la cambiamos con bigLargeIcon(). En el ejemplo he decidido que la imagen de la notificación en su forma contraída será la misma que la imagen grande en la forma expandida, en cuyo caso la imagen a la izquierda será otra, por ejemplo el icono de la aplicación. Para muestra un botón.

 

 

Inbox, línea a línea

El último estilo que tenemos es el InboxStyle, que muestra una lista de texto. Como varios correos recibidos, o lo que nos escribe alguien por mensajería instantánea. Muy similar también a los anteriores.

 

private Notification getInboxStyle(Notification.Builder builder) {
		builder
			.setContentTitle("Reduced Inbox title")
			.setContentText("Reduced content")
			.setContentInfo("Info")
			.setSmallIcon(R.drawable.ic_launcher)
			.setLargeIcon(bitmapIcon);

		Notification.InboxStyle n = new Notification.InboxStyle(builder)
				.setBigContentTitle("Expanded Inbox title")
				.setSummaryText("Summary text");

		for(String line : lineList){
			n.addLine(line);
		}
		return n.build();
	}

 

En esta ocasión añadimos las líneas una a una con addLine(), aunque nos aconsejan un máximo de 5. No tiene mucho misterio. Nos queda algo así:

 

 

Botones

Otra novedad introducida en Jelly Bean es la posibilidad de añadir hasta 3 botones a las notificaciones con sus acciones asociadas. Se hace sobre el objeto de tipo Notification.Builder con el método addAction(), así que es compatible con cualquiera de los 4 tipos de notificaciones anteriores (el tradicional no). En la notificación normal los botones se considerarán como parte “expandida”, por lo que tendrán el mismo comportamiento que las notificaciones grandes.

 

 

En el ejemplo vemos un método que añade 2 botones a cualquier builder que pasemos como parámetro.

 

private void setButtons(Notification.Builder builder) {
		builder.addAction(android.R.drawable.ic_menu_delete, "Delete", deleteIntent);
		builder.addAction(android.R.drawable.ic_menu_share, "Share", shareIntent);
	}

 

Le pasamos como parámetros un drawable del icono que llevará el botón a la izquierda del texto, el texto que llevará, y un PendingIntent que se activará cuando pulsemos el botón. Así de fácil y así de bien.

 

Prioridades

Por último tenemos el concepto de prioridad en la notificaciones. Podemos asignarle diferentes niveles a nuestra notificación para que aparezcan en la bandeja más arriba según lo importante que sea. Hay 5 niveles: Máxima (reservada para cosas de gran urgencia como llamadas, generalmente nunca la usaremos), alta, por defecto, baja y mínima (que aparece en la bandeja pero no en la barra superior). Debemos hacer un uso responsable, y si usamos una prioridad alta estar seguros de que el usuario así lo necesitará.

Pues bueno, asignar una prioridad es tan sencillo como llamar al método setPriority() del Notification.Builder

 

builder.setPriority(Notification.PRIORITY_LOW);

 

Las constantes son por orden PRIORITY_MAX, PRIORITY_HIGH, PRIORITY_DEFAULT, PRIORITY_LOW y PRIORITY_MIN.

Nota: las prioridades son una “pista” para el sistema, no una regla.  Pueden no cumplirse si el sistema lo cree oportuno.

 

Algunos extras

Por ahora todo lo que hemos visto ha sido para crear la notificación, pero aún tenemos que mostrarla y quizá hacer que el móvil suene y/o vibre. En versiones anteriores de Android se hace modificando determinadas propiedades del objeto Notification. Desde Honeycomb en adelante se hace, cómo no, con el Notification.Builder. Veamos unos ejemplos.

 

Sonido

Podemos reproducir un sonido al activar la notificación.

 

// Sonido por defecto de notificaciones, podemos usar otro
Uri defaultSound = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);

// Uso en API 10 o menor
notification.sound = defaultSound

// Uso en API 11 o mayor
builder.setSound(defaultSound);

 

Vibración

También podemos hacer que el teléfono vibre. Para eso lo primero que necesitamos es declarar el permiso de vibración.

 

<uses-permission android:name="android.permission.VIBRATE" />

 

Luego creamos un patrón de vibración. Consiste en un array de long alternando el tiempo de vibración y pausa en milisegundos. Y se lo asignamos a la notificación.

 

// Patrón de vibración: 1 segundo vibra, 0.5 segundos para, 1 segundo vibra
long[] pattern = new long[]{1000,500,1000};

// Uso en API 10 o menor
notification.vibrate = pattern;

// Uso en API 11 o mayor
builder.setVibrate(pattern);

 

Led

Algunos teléfonos también tienen un led de notificación que podemos usar. Hay 3 parámetros: el color del led (como cada dispositivo tiene diferentes limitaciones en este aspecto, se usará la mejor aproximación posible), y 2 parámetros, ledOnMS y ledOffMS, para especificar la frecuencia de parpadeo (aunque la mayoría de dispositivos ignoran estos valores, así que usamos 1 y 0 respectivamente para encenderlo).

 

// API 10 o menor
notification.ledARGB = Color.RED;
notification.ledOnMS = 1;
notification.ledOffMS = 0;
notification.flags = notification.flags | Notification.FLAG_SHOW_LIGHTS;

// API 11 o mayor
builder.setLights(Color.RED, 1, 0);

 

Notificaciones insistentes y en curso

También podemos establecer nuestras notificaciones como insistentes, para que repitan indefinidamente su sonido, vibración y luces; o en curso para que se mantengan en la bandeja sin poder quitarse. Las primeras son útiles para casos de prioridad máxima como llamadas o alarmas, mientras que las segundas se pueden usar para indicar al usuario que hay un proceso ejecutándose en segundo plano (como un servicio). En cualquiera de los dos casos es muy importante que demos la posibilidad de cancelar la notificación o el evento, o podemos cabrear a nuestros usuarios.

 

// Insistente
// Son tan intrusivas que han decidido no añadir un método para esto en el Builder
// Se hace igual para todos los niveles de API
notification.flags = notification.flags | Notification.FLAG_INSISTENT;

// En curso
// -- API 10 o menor
notification.flags = notification.flags | Notification.FLAG_ONGOING_EVENT;
// -- API 11 o mayor
builder.setOngoing(true);

 

Auto-cancelación

Además se permite y recomienda que una notificación se cancele automáticamente cuando pulsamos sobre ella. Podemos activar esta función:

 

// API 10 o menor
notification.flags = notification.flags | Notification.FLAG_AUTO_CANCEL;

// API 11 o mayor
builder.setAutoCancel(true);

 

Ahora sí, lanzando la notificación

Una vez tenemos nuestra notificación como queremos, es hora de lanzarla para que la reciba el usuario. Esto se hace mediante el NotificationManager. Debemos obtener la instancia de este servicio, y pasarle la notificación y un número de referencia que identifique nuestra notificación.

 

NotificationManager notifManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);

int notif_ref = 1;

notifManager.notify(notif_ref, notification);

 

Y listo, notificación enviada. Para actualizar una notificación sin enviar una nueva sólo tenemos que enviarla usando el mismo número de referencia y se sobreescribirá. También podemos cancelarla manualmente (importante para insistentes y en curso) haciendo

 

notifManager.cancel(notif_ref);

 

Y con esto hemos dado un repaso general a las famosas e insuperables notificaciones de Android. Con lo visto estarán cubiertas la gran mayoría de necesidades. Tienen algunas más opciones de personalización, pero tampoco es cuestión de extenderse más. Si necesitáis algo podéis preguntar en los comentarios.

Os recomiendo que paséis por el apartado de notificaciones de Android Design para ver las recomendaciones a la hora de crear notificaciones consistentes con el sistema.

Las capturas de pantalla las he sacado de una aplicación que he hecho para demostrar el uso de las nuevas notificaciones de Jelly Bean. Podéis descargar la aplicación del Play Store si tenéis Jelly Bean, o ver el código fuente en GitHub, que puede servir para ver en funcionamiento el Notification.Builder (la aplicación está restringida a Jelly Bean pero el código es compatible con Honeycomb en adelante).

Nada más. Espero que os haya resultado útil.

 

La imagen de la cabecera está sacada de la charla de Reto Meier en el Google IO 2012: Aquí
 

Acerca del autor

Rafa Vázquez

Estudio Ingeniería Informática del Software en Sevilla. Me considero geek sin dinero, amante y desarrollador novato de Android. He creado algunas aplicaciones como SeviBus, TicTacDroide, Kill Bieber y Traductor Hoygan, si es que se puede llamar aplicaciones a estas dos últimas ;) Ganas de aprender más y más no me faltan, e intentaré compartir mis experiencias con vosotros en la medida de lo posible.

  • Igor

    Buenas, soy novato en esto de Android y programando en general. Existe alguna posibilidad de poder mandar notificaciones a mi aplicación remotamente? No tengo ni idea de cómo se haría ni si existe algún ejemplo o tutorial para ello. Gracias

  • http://www.limecreativelabs.com Antonio

    Impresionante este artículo. Por experiencia personal, sé que utilizar estas librerías de notificaciones es un tema tedioso. Estaba creando un artículo al respecto, sobre todo para explicar las novedades en Jelly Bean, pero me estaba llevando tanto tiempo que lo tenía aparcado.

    Reconozco que por falta de investigación no sé muy bien cómo hacer lo siguiente: ¿cómo puedo utilizar toda la potencia de las notificaciones de Android en Jelly Bean manteniendo la compatibilidad con el resto de versiones? Esto es aplicable a cualquier novedad que incluya el API y que no esté incluida en el Support Package. ¿Hay que crear bloques de código para cada una y forzar a que se ejecute uno u otro en función de la versión del dispositivo? ¿O hay alguna solución mejor?

    • http://about.me/sloy Sloy | Editor

      Buenas Antonio,
      Se puede perfectamente usar las notificaciones de Jelly Bean manteniendo las normales para versiones que no las soporten. Más que se puede, se debe. Y es realmente sencillo, te comento dos métodos, el difícil y el fácil.

      El más difícil (que no deja de ser bastante sencillo) es encargarte tú de ellos. Como ves, los constructores de notificaciones grandes devuelven, al igual que los normales, un objeto de tipo Notification. Sería tan sencillo como hacer una notificación normal, y dentro de un bloque if (si la versión es 4.1 o superior) le añades la funcionalidad extra. Luego ese objeto Notification lo lanzas como explico en el post y listo.

      El otro método es algo más fácil y rápido, usando la librería que pongo arriba, NotificationCompat2. El SupportPackage incluye la clase NotificationCompat para crear notificaciones usando un Builder en versiones anteriores a 3.0, pero NotificationCompat2 es una librería no oficial creada por Jake Wharton que extiende esa misma idea a las notificaciones de Jelly Bean. Usando esa librería puedes crear notificaciones grandes y ella se encargará de construirlas grandes o normales según la versión del dispositivo. Echa un ojo al ejemplo y verás lo sencillo que es.
      https://github.com/JakeWharton/NotificationCompat2

      Espero que te sirva, un saludo.

  • Sergio

    Excelente documentación!! me sirvió muchísimo para implementar las notificaciones en mi aplicación!

  • Hugo

    Hola, soy de Argentina. Justo estoy con el tema de Notificaciones Push para dos aplicaciónes hecha en Android con código Nativo y con PhoenaGap (Cordova). Me viene de 10 esta guía ya que estaba buscando como mejorar las notificaciones.

  • http://www.facebook.com/pedrodsanchez Pedro Sanchez

    hola yo utilizo esto
    //Obtenemos una referencia al servicio de notificaciones
    String ns = Context.NOTIFICATION_SERVICE;
    NotificationManager notManager = (NotificationManager) getSystemService(ns);

    //Configuramos la notificación
    int icono = R.drawable.ic_launcher;
    CharSequence textoEstado = “Nueva Oferta”;
    long hora = System.currentTimeMillis();

    Notification notif =new Notification(icono, textoEstado, hora);

    //Configuramos el Intent
    Context contexto = getApplicationContext();
    CharSequence titulo = “Nueva oferta”;
    CharSequence descripcion;
    if(++numMessages>1)
    descripcion = “Te han enviado”+ Integer.toString(numMessages) +”oferta”;
    else
    descripcion = “Te han enviado una oferta”;

    Intent notIntent = new Intent(contexto,Principal.class);

    PendingIntent contIntent = PendingIntent.getActivity(contexto, 0, notIntent, 0);

    notif.setLatestEventInfo(contexto, titulo, descripcion, contIntent);

    //AutoCancel: cuando se pulsa la notificaión ésta desaparece
    notif.flags |= Notification.FLAG_AUTO_CANCEL;
    notif.defaults |= Notification.DEFAULT_SOUND;
    //Añadir sonido, vibración y luces
    //notif.defaults |= Notification.DEFAULT_SOUND;
    //notif.defaults |= Notification.DEFAULT_VIBRATE;
    //notif.defaults |= Notification.DEFAULT_LIGHTS;

    //Enviar notificación
    notManager.notify(NOTIF_ALERTA_ID, notif);

    necesito actualizar la cantidad de notificaciones como haria??

    • http://rafagames.wordpress.com rafagames

      Hola Pedro,
      para actualizar una notificación, sólo tienes que enviar una nueva usando el mismo ID en el método notify() del NotificationManager. Puedes reaprovechar el objeto Notification que creaste y modificarle lo que necesites, o crear uno nuevo. Lo importante es usar la misma ID.

  • https://plus.google.com/105192915223982899808 Gilberto Ibarra

    PAra versiones anteriores esta no es compatible. por lo que yo una vez hize un metodo llamado BuildNormal y le agregue unas cositas asi:

    mNotificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);

    // para usar las notificaciones

    NotificationCompat.Builder normal = buildNormal();
    Notification notification= normal.build();
    notification.vibrate = vibrate;
    notification.flags |= notification.flags | Notification.FLAG_INSISTENT;
    notification.flags |= Notification.FLAG_AUTO_CANCEL;

    mNotificationManager.notify(11, notification);

    // metodo

    private NotificationCompat.Builder buildNormal() {
    NotificationCompat.Builder b = new NotificationCompat.Builder(mContext.getApplicationContext());

    b.setAutoCancel(true)
    .setDefaults(Notification.DEFAULT_ALL)
    .setWhen(System.currentTimeMillis())
    .setSmallIcon(R.drawable.ic_launcher)
    .setTicker(“Optional ticker”)
    .setContentTitle(“Default notification”)
    .setContentText(“Lorem ipsum dolor sit amet, consectetur adipiscing elit.”)
    .setDefaults(Notification.DEFAULT_LIGHTS| Notification.DEFAULT_VIBRATE| Notification.DEFAULT_SOUND)
    .setContentIntent(buildPendingIntent())
    .setContentInfo(“Info”);

    return b;
    }

  • http://gravatar.com/patolala patolalapatricio

    Hola estimado, te cuento que no se nada de programacion, nada, pertenezco a un coro y mi intencion es tener una aplicacion en donde los integrantes del coro, puedan conocer de ensayos o reuniones, para esto “realice” una aplicacion en Ibuildapp.com pero me falla lo mas importante, que son las notificaciones, si bien hay un tutorial de como configurarlo, no logro realizarlo, esta app es gratuita y nuestro coro es sin fines de lucro.
    Me podrias dar una mano?

    Gracias

  • loga

    Excelente tutorial, me ayudado de mucho, una duda es posible asociar un sonido a la notificación ejemplo “tienes una nueva notificación o algún sonido”, como y donde guardaría el mp3 y como lo llamaría, según yo la llamo asi: .setSound(Uri.parse(“file:///sdcard/carpeta/sonido.mp3″))
    Saludos

    • http://about.me/sloy Rafa Vázquez

      En teoría no habría ningún problema. Podrías almacenar el sonido en la memoria sd y usar la uri correspondiente para reproducirlo en la notificación.

  • joluco

    Hola compañer@s de fatigas. Rafa y demás que leais esto, os cuento mi problema;

    Tengo dos aplicaciones distintas que acceden al mismo fichero de Texto via FTP. Una de esas aplicaciones pueden modificar ese archivo de texto, la otra solo leerlo.

    Mi intención es que cuando la primera aplicación modifique el archivito de texto, en la segunda aparezca una notificación en la barra de estado indicando que ha habido cambios. Esta notificación me gustaría hacerla incluso aunque la aplicación estuviera cerrada. Vamos, tipo notificaciones del Whatsapp, por ejemplo. ¿CÓMO HAGO ESO?

    Supongo que para hacer esto la aplicación que lee los ficheros debería lanzar un proceso en segundo plano y estar cada X tiempo comprobando si el archivo ha cambiado y una vez que se modifique, notifique de ello. Pero esto no se muy bien como llevarlo a la programación.

    Para que la aplicación que lee el fichero detecte cambios, se me había ocurrido que el propio fichero incluyera un registro tipo #Cambio:0/1. Una vez que se modifica este fichero el campo #Cambio valdría 1 (#Cambio=1) si no hay cambios #Cambio=0. De este modo la aplicación que lee el fichero comprobaría primero el valor de este campo y si está a 1 lanzaría la notificación.

    El problema que veo es que si la aplicación está continuamente comprobando si hay cambios, por ejemplo cada hora, se lanzarían notificaciones cada hora a no ser que se volviera a a poner
    #Cambio a 0 y si esto se hace, a otros usuarios puede que no les haya dado tiempo a recibir la notificación. Como veis estoy un poco verde en esto. AYUDA, POR FAVOR.

    MUCHAS GRACIAS.

  • Wee

    Estoy haciendo Desarrollo de Aplicaciones Multiplataforma, y éste post encontré lo que necesitaba. Mil gracias!!

  • Manu

    Brutal Rafa, una genialidad. Completo, sencillo e ilustrativo.

  • Manuel Paz

    Hola! tengo una pregunta, como puedo hacer que mi aplicación este recibiendo siempre notificaciones, aún cuando no este abierta??
    Así como las notificaciones que te llegan de Facebook, Whatsapp…

  • Josmary

    Hola tengo un duda de como hacer que mi aplicacion reciba notificacion cuando otro usuario ha respondido una pregunta en un foro?

  • Alfredo García

    Buenas tardes. Amigo Rafa, ¿sabe cómo desactivar la vibración para las notificaciones y el ring del teléfono?

    Agradezco tu ayuda

  • Matias

    Muchas gracias!!!! ha sido de gran ayuda el tuto!!!

  • Kevin Romero

    Excelente e interesante articulo, muchas gracias Parcero!!

  • María

    Muchas gracias por el tutorial, me ha sido realmente útil pero te informo que con el paso de los años, lamentablemente, ya no se pueden implementar ciertas funciones en las últimas versiones. Pero nada que no se pueda solventar ;)

  • estelaacv alava carranza

    Muy buen tutorial, también os puede ser de gran ayuda esta app Notificador para WhatsApp es gratuita mediante este enlace: https://play.google.com/store/apps/details?id=beta.updates.whatsapp&hl=es; a mi me resuelve muchas dudas a la hora de obtener respuestas de diferentes preguntas referente a Whatsapp además me notifica cada vez que existe nueva actualización de Whatsapp para mi de cinco estrella os la recomiendo sin duda alguna.

  • Fernando Manuel Zamudio Corral

    Buen dia Rafa ! estoy desarrollando una aplicacion y quisiera saber si se puede LEER las notificaciones ! ya vi q se pueden crear pero tengo una aplicacion donde debo leerlas… quiero saber por lo menos saber si se puede saludos !