Android => Les notifications

Créer une notification simple

Cet exemple montre comment créer une notification simple qui démarre une application lorsque l'utilisateur clique dessus.

Spécifiez le contenu de la notification:

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

Créez l'intention de tirer sur le clic:

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

Enfin, créez la notification et affichez-la

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

Notification Heads Up avec Ticker pour les anciens appareils

Voici comment créer une notification Heads Up pour les périphériques compatibles et utiliser un ticker pour les anciens appareils.

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

Voici à quoi il ressemble sur Android Marshmallow avec la notification Heads Up:

Voici à quoi ça ressemble sur Android KitKat avec le Ticker:

Sur toutes les versions Android, la Notification est affichée dans le tiroir de notification.

Android 6.0 Guimauve:

Android 4.4.x KitKat:

Définition de différentes priorités dans la notification

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

Lorsque la notification contient une image et que vous souhaitez étendre automatiquement l'image lorsque la notification reçue utilise "PRIORITY_MAX", vous pouvez utiliser d'autres niveaux de priorité selon les exigences

Différents niveaux de priorité Info:

PRIORITY_MAX - Utilisé pour les notifications critiques et urgentes qui alertent l'utilisateur sur une condition critique dans le temps ou devant être résolue avant de pouvoir poursuivre une tâche particulière.

PRIORITY_HIGH - Utilisé principalement pour les communications importantes, telles que les messages ou les événements de discussion avec un contenu particulièrement intéressant pour l'utilisateur. Les notifications de haute priorité déclenchent l'affichage de la notification tête haute.

PRIORITY_DEFAULT - Utilisé pour toutes les notifications qui ne correspondent à aucune des priorités décrites ici.

PRIORITY_LOW - Utilisez cette option pour les notifications dont vous souhaitez que l'utilisateur soit informé, mais qui sont moins urgentes. Les notifications de faible priorité ont tendance à apparaître au bas de la liste, ce qui en fait un bon choix pour des choses telles que les mises à jour sociales publiques ou non dirigées: l'utilisateur a demandé à être averti, mais ces notifications communication directe.

PRIORITY_MIN - Utilisé pour des informations contextuelles ou d'arrière-plan telles que des informations météorologiques ou des informations de localisation contextuelles. Les notifications de priorité minimale n'apparaissent pas dans la barre d'état. L'utilisateur les découvre lors de l'extension de la nuance de notification.

Références: Lignes directrices pour la conception des matériaux - notifications

Notifications de planification

Parfois, il est nécessaire d'afficher une notification à un moment précis, une tâche qui n'est malheureusement pas triviale sur le système Android, car il n'y a pas de méthode setTime() ou similaire pour les notifications. Cet exemple décrit les étapes nécessaires pour planifier des notifications à l'aide du AlarmManager :

Ajoutez un BroadcastReceiver qui écoute les Intent diffusées par le AlarmManager Android.

C'est l'endroit où vous créez votre notification en fonction des extras fournis avec l' 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);
       }
   }

Enregistrez le BroadcastReceiver dans votre fichier AndroidManifest.xml (sinon, le récepteur ne recevra aucune Intent du AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

Planifier une notification en transmettant un PendingIntent pour votre BroadcastReceiver avec les extras Intent nécessaires au système AlarmManager . Votre BroadcastReceiver recevra l’ Intent une fois l’heure donnée et affichera la notification. La méthode suivante permet de planifier une notification:

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

S'il vous plaît noter que le 42 ci-dessus doit être unique pour chaque notification planifiée, sinon les PendingIntent s se remplaceront mutuellement provoquant des effets indésirables!

Annulez une notification en reconstruisant le PendingIntent associé et en l'annulant sur le AlarmManager du système. La méthode suivante annule une notification:

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

Notez que le 42 ci-dessus doit correspondre au numéro de l'étape 3!

Définir une notification personnalisée - affiche le texte intégral du contenu

Si vous voulez avoir un long texte à afficher dans le contexte, vous devez définir un contenu personnalisé.

Par exemple, vous avez ceci:

Mais vous souhaitez que votre texte soit entièrement montré:

Tout ce que vous avez à faire est d' ajouter un style à votre contenu comme ci-dessous:

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

Définir l'icône de notification personnalisée en utilisant la bibliothèque `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);

Et puis définissez une mise en page dans votre dossier de mises en page:

<?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>

Obtenir dynamiquement la taille de pixel correcte pour la grande icône

Si vous créez une image, décodez une image ou redimensionnez une image pour l'adapter à la grande zone d'image de notification, vous pouvez obtenir les dimensions de pixel correctes comme suit:

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

Notification en cours avec le bouton Action

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

Enregistrez un récepteur de diffusion pour la même action pour gérer l'événement de clic du bouton d'action.

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

Android
Les notifications

Recherche…