Android => Notificaciones

Creando una notificación simple

Este ejemplo muestra cómo crear una notificación simple que inicia una aplicación cuando el usuario hace clic en ella.

Especifique el contenido de la notificación:

NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
        .setSmallIcon(R.drawable.ic_launcher) // notification icon
        .setContentTitle("Simple notification") // title
        .setContentText("Hello word") // body message
        .setAutoCancel(true); // clear notification when clicked

Crea la intención de disparar al hacer clic:

Intent intent = new Intent(this, MainActivity.class);
PendingIntent pi = PendingIntent.getActivity(this, 0, intent, Intent.FLAG_ACTIVITY_NEW_TASK);
mBuilder.setContentIntent(pi);

Finalmente, construya la notificación y muéstrela.

NotificationManager mNotificationManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify(0, mBuilder.build());

Heads Up Notification with Ticker para dispositivos más antiguos

Aquí se explica cómo realizar una Notificación de Heads Up para dispositivos con capacidad y utilizar un Ticker para dispositivos más antiguos.

// Tapping the Notification will open up MainActivity
Intent i = new Intent(this, MainActivity.class);

// an action to use later
// defined as an app constant:
// public static final String MESSAGE_CONSTANT = "com.example.myapp.notification";
i.setAction(MainActivity.MESSAGE_CONSTANT);
// you can use extras as well
i.putExtra("some_extra", "testValue");

i.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT | Intent.FLAG_ACTIVITY_SINGLE_TOP);
PendingIntent notificationIntent = PendingIntent.getActivity(this, 999, i, PendingIntent.FLAG_UPDATE_CURRENT);
NotificationCompat.Builder builder = new NotificationCompat.Builder(this.getApplicationContext());
builder.setContentIntent(notificationIntent);
builder.setAutoCancel(true);
builder.setLargeIcon(BitmapFactory.decodeResource(this.getResources(), android.R.drawable.ic_menu_view));
builder.setSmallIcon(android.R.drawable.ic_dialog_map);
builder.setContentText("Test Message Text");
builder.setTicker("Test Ticker Text");
builder.setContentTitle("Test Message Title");

// set high priority for Heads Up Notification
builder.setPriority(NotificationCompat.PRIORITY_HIGH);
builder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);

// It won't show "Heads Up" unless it plays a sound
if (Build.VERSION.SDK_INT >= 21) builder.setVibrate(new long[0]);

NotificationManager mNotificationManager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
mNotificationManager.notify(999, builder.build());

Esto es lo que parece en Android Marshmallow con la Notificación de Heads Up:

Aquí está lo que parece en Android KitKat con el Ticker:

En todas las versiones de Android, la Notification se muestra en el cajón de notificaciones.

Android 6.0 Marshmallow:

Android 4.4.x KitKat:

Establecer diferentes prioridades en la notificación

 NotificationCompat.Builder mBuilder =

        (NotificationCompat.Builder) new NotificationCompat.Builder(context)

        .setSmallIcon(R.drawable.some_small_icon)
        .setContentTitle("Title")
        .setContentText("This is a test notification with MAX priority")
        .setPriority(Notification.PRIORITY_MAX);

Cuando la notificación contiene imagen y desea expandir automáticamente la imagen cuando se recibe la notificación, use "PRIORITY_MAX", puede usar otros niveles de prioridad según los requisitos

Información de diferentes niveles de prioridad:

PRIORITY_MAX : se usa para notificaciones críticas y urgentes que alertan al usuario sobre una condición que es crítica en el tiempo o que debe resolverse antes de que puedan continuar con una tarea en particular.

PRIORITY_HIGH : se usa principalmente para comunicaciones importantes, como mensajes o eventos de chat con contenido que es particularmente interesante para el usuario. Las notificaciones de alta prioridad activan la visualización de la notificación de heads-up.

PRIORITY_DEFAULT : se usa para todas las notificaciones que no corresponden a ninguna de las otras prioridades descritas aquí.

PRIORITY_LOW : se utiliza para las notificaciones sobre las que desea que se informe al usuario, pero que sean menos urgentes. Las notificaciones de baja prioridad tienden a aparecer en la parte inferior de la lista, lo que las convierte en una buena opción para cosas como actualizaciones sociales públicas o no dirigidas: el usuario ha solicitado ser notificado de ellas, pero estas notificaciones nunca deben tener prioridad sobre las urgentes o comunicación directa.

PRIORITY_MIN : se usa para obtener información contextual o de fondo, como información meteorológica o información de ubicación contextual. Las notificaciones de prioridad mínima no aparecen en la barra de estado. El usuario los descubre al expandir el tono de notificación.

Referencias: Pautas de diseño de materiales - notificaciones

Programación de notificaciones

A veces es necesario mostrar una notificación en un momento específico, una tarea que desafortunadamente no es trivial en el sistema Android, ya que no existe un método setTime() o similar para las notificaciones. Este ejemplo describe los pasos necesarios para programar notificaciones utilizando el AlarmManager :

Agregue un BroadcastReceiver que escuche los Intent emitidos por el AlarmManager Android.

Este es el lugar donde construyes tu notificación en base a los extras provistos con la Intent :

   public class NotificationReceiver extends BroadcastReceiver {
       @Override
       public void onReceive(Context context, Intent intent) {
           // Build notification based on Intent
           Notification notification = new NotificationCompat.Builder(context)
               .setSmallIcon(R.drawable.ic_notification_small_icon)
               .setContentTitle(intent.getStringExtra("title", ""))
               .setContentText(intent.getStringExtra("text", ""))
               .build();
           // Show notification
           NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
           manager.notify(42, notification);
       }
   }

Registre BroadcastReceiver en su archivo AndroidManifest.xml (de lo contrario, el receptor no recibirá ninguna Intent del AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

Programe una notificación pasando un PendingIntent para su BroadcastReceiver con los extras de Intent necesarios al AlarmManager sistema. Su BroadcastReceiver recibirá la Intent una vez que haya llegado el momento y mostrará la notificación. El siguiente método programa una notificación:

public static void scheduleNotification(Context context, long time, String title, String text) {
    Intent intent = new Intent(context, NotificationReceiver.class);
    intent.putExtra("title", title);
    intent.putExtra("text", text);
    PendingIntent pending = PendingIntent.getBroadcast(context, 42, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    // Schdedule notification
    AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    manager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, time, pending);
}

Tenga en cuenta que el 42 por encima tiene que ser único para cada notificación programada, de lo contrario el PendingIntent s reemplazará unos a otros efectos no deseados que causan!

Cancele una notificación al reconstruir el PendingIntent asociado y cancelarlo en el AlarmManager sistema. El siguiente método cancela una notificación:

public static void cancelNotification(Context context, String title, String text) {
    Intent intent = new Intent(context, NotificationReceiver.class);
    intent.putExtra("title", title);
    intent.putExtra("text", text);
    PendingIntent pending = PendingIntent.getBroadcast(context, 42, intent, PendingIntent.FLAG_UPDATE_CURRENT);
    // Cancel notification
    AlarmManager manager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
    manager.cancel(pending);
}

¡Tenga en cuenta que el 42 anterior debe coincidir con el número del paso 3!

Establecer notificación personalizada: muestra el contenido completo del texto

Si desea que se muestre un texto largo en el contexto, debe configurar un contenido personalizado.

Por ejemplo, tienes esto:

Pero deseas que tu texto se muestre completamente:

Todo lo que necesita hacer es agregar un estilo a su contenido como a continuación:

  private void generateNotification(Context context) {
        String message = "This is a custom notification with a very very very very very very very very very very long text";
        Bitmap largeIcon = BitmapFactory.decodeResource(getResources(), android.R.drawable.ic_dialog_alert);

        NotificationCompat.Builder builder = new NotificationCompat.Builder(context);

        builder.setContentTitle("Title").setContentText(message)
                .setSmallIcon(android.R.drawable.ic_dialog_alert)
                .setLargeIcon(largeIcon)
                .setAutoCancel(true)
                .setWhen(System.currentTimeMillis())
                .setStyle(new NotificationCompat.BigTextStyle().bigText(message));

        Notification notification = builder.build();
        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
        notificationManager.notify(101, notification);
    }

Establecer el icono de notificación personalizado usando la biblioteca `Picasso`.

    PendingIntent pendingIntent = PendingIntent.getActivity(context,
    uniqueIntentId, intent, PendingIntent.FLAG_CANCEL_CURRENT);

    final RemoteViews remoteViews = new RemoteViews(context.getPackageName(), R.layout.remote_view_notification);
    remoteViews.setImageViewResource(R.id.remoteview_notification_icon, R.mipmap.ic_navigation_favorites);

    Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
    NotificationCompat.Builder notificationBuilder =
            new NotificationCompat.Builder(context)
                    .setSmallIcon(R.mipmap.ic_navigation_favorites) //just dummy icon
                    .setContent(remoteViews) // here we apply our view
                    .setAutoCancel(true)
                    .setContentIntent(pendingIntent)
                    .setPriority(NotificationCompat.PRIORITY_DEFAULT);

    final Notification notification = notificationBuilder.build();

    if (android.os.Build.VERSION.SDK_INT >= 16) {
        notification.bigContentView = remoteViews;
    }

    NotificationManager notificationManager =
            (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

    notificationManager.notify(uniqueIntentId, notification);


    //don't forget to include picasso to your build.gradle file.
    Picasso.with(context)
            .load(avatar)
            .into(remoteViews, R.id.remoteview_notification_icon, uniqueIntentId, notification);

Y luego define un diseño dentro de tu carpeta de diseños:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@android:color/white"
    android:orientation="vertical">



    <ImageView
        android:id="@+id/remoteview_notification_icon"
        android:layout_width="60dp"
        android:layout_height="60dp"
        android:layout_marginRight="2dp"
        android:layout_weight="0"
        android:scaleType="centerCrop"/>
</LinearLayout>

Obtener dinámicamente el tamaño de píxel correcto para el icono grande

Si está creando una imagen, decodificando una imagen o cambiando el tamaño de una imagen para que se ajuste al área de imagen de notificación grande, puede obtener las dimensiones de píxeles correctas de la siguiente manera:

Resources resources = context.getResources();
int width  = resources.getDimensionPixelSize(android.R.dimen.notification_large_icon_width);
int height = resources.getDimensionPixelSize(android.R.dimen.notification_large_icon_height);

Notificación continua con botón de acción

// Cancel older notification with same id,
NotificationManager notificationMgr = (NotificationManager)context.getSystemService(Context.NOTIFICATION_SERVICE);
notificationMgr.cancel(CALL_NOTIFY_ID);// any constant value
    
// Create Pending Intent,
Intent notificationIntent = null;
PendingIntent contentIntent = null;            
notificationIntent = new Intent (context, YourActivityName); 
contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, PendingIntent.FLAG_UPDATE_CURRENT); 
        
// Notification builder 
builder = new NotificationCompat.Builder(context);
builder.setContentText("Ongoing Notification..");
builder.setContentTitle("ongoing notification sample");
builder.setSmallIcon(R.drawable.notification_icon);
builder.setUsesChronometer(true);
builder.setDefaults(Notification.DEFAULT_LIGHTS);
builder.setContentIntent(contentIntent);
builder.setOngoing(true);
    
// Add action button in the notification 
Intent intent = new Intent("action.name");
PendingIntent pIntent = PendingIntent.getBroadcast(context, 1, intent, 0);
builder.addAction(R.drawable.action_button_icon, "Action button name",pIntent); 
 
// Notify using notificationMgr
Notification finalNotification = builder.build();
notificationMgr.notify(CALL_NOTIFY_ID, finalNotification);

Registre un receptor de difusión para la misma acción para manejar el evento de clic del botón de acción.

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

Android
Notificaciones

Buscar..