Android => notifiche

Creazione di una notifica semplice

Questo esempio mostra come creare una semplice notifica che avvia un'applicazione quando l'utente fa clic su di essa.

Specificare il contenuto della notifica:

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 l'intento di sparare al clic:

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

Infine, crea la notifica e mostrala

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

Avvisa la notifica con Ticker per i dispositivi più vecchi

Ecco come effettuare una notifica di avviso per dispositivi abilitati e utilizzare un segno di spunta per i dispositivi più vecchi.

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

Ecco come appare su Android Marshmallow con la notifica Heads Up:

Ecco come appare su Android KitKat con il Ticker:

Su tutte le versioni di Android, la Notification viene visualizzata nel cassetto delle notifiche.

Android 6.0 Marshmallow:

Android 4.4.x KitKat:

Impostazione di priorità diverse nella notifica

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

Quando la notifica contiene un'immagine e si desidera espandere automaticamente l'immagine quando la notifica ricevuta utilizza "PRIORITY_MAX", è possibile utilizzare altri livelli di priorità come da requisiti

Informazioni sui livelli di priorità diversi:

PRIORITY_MAX : utilizzare per notifiche critiche e urgenti che avvisano l'utente di una condizione che è cruciale in termini di tempo o che deve essere risolta prima di poter continuare con una determinata attività.

PRIORITY_HIGH : utilizza principalmente comunicazioni importanti, come messaggi o eventi di chat con contenuti particolarmente interessanti per l'utente. Le notifiche ad alta priorità attivano la visualizzazione delle notifiche heads-up.

PRIORITY_DEFAULT - Utilizza per tutte le notifiche che non rientrano in nessuna delle altre priorità descritte qui.

PRIORITY_LOW - Utilizzare per le notifiche di cui si desidera informare l'utente, ma che sono meno urgenti. Le notifiche a bassa priorità tendono a comparire in fondo all'elenco, il che le rende una buona scelta per cose come aggiornamenti sociali pubblici o non orientati: l'utente ha chiesto di essere informato su di loro, ma queste notifiche non dovrebbero mai avere la precedenza su quelle urgenti o comunicazione diretta.

PRIORITY_MIN : utilizzare per informazioni contestuali o di background quali informazioni meteo o informazioni sulla posizione contestuale. Le notifiche con priorità minima non vengono visualizzate nella barra di stato. L'utente li scopre espandendo la tonalità di notifica.

Riferimenti: linee guida sulla progettazione dei materiali - notifiche

Pianificazione delle notifiche

A volte è necessario visualizzare una notifica in un momento specifico, un'attività che sfortunatamente non è banale sul sistema Android, in quanto non esiste alcun metodo setTime() o simile per le notifiche. Questo esempio delinea i passaggi necessari per pianificare le notifiche utilizzando AlarmManager :

Aggiungi un BroadcastReceiver che ascolti i messaggi di Intent trasmessi da Android AlarmManager .

Questo è il posto dove si costruisce la notifica in base agli extra forniti con 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);
       }
   }

Registrare il BroadcastReceiver nel file AndroidManifest.xml (altrimenti il ricevitore non riceverà alcun Intent da AlarmManager ):
```
<receiver
    android:name=".NotificationReceiver"
    android:enabled="true" />
```

Pianificare una notifica passando un PendingIntent per BroadcastReceiver con gli extra Intent necessari al sistema AlarmManager . Il tuo BroadcastReceiver riceverà l' Intent una volta che l'ora è arrivata e mostrerà la notifica. Il seguente metodo pianifica una notifica:

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

Si prega di notare che il 42 sopra deve essere univoco per ogni notifica programmata, altrimenti i PendingIntent si sostituiranno a vicenda causando effetti indesiderati!

Annullare una notifica ricostruendo il PendingIntent associato e cancellandolo sul sistema AlarmManager . Il seguente metodo annulla una notifica:

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

Si noti che il 42 sopra deve corrispondere al numero del passaggio 3!

Imposta notifica personalizzata - mostra il testo del contenuto completo

Se si desidera visualizzare un testo lungo nel contesto, è necessario impostare un contenuto personalizzato.

Ad esempio, hai questo:

Ma desideri che il tuo testo sia mostrato integralmente:

Tutto quello che devi fare è aggiungere uno stile ai tuoi contenuti come di seguito:

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

Imposta l'icona di notifica personalizzata usando la libreria `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);

E quindi definire un layout all'interno della cartella dei layout:

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

Ottenere in modo dinamico la dimensione dei pixel corretta per l'icona grande

Se stai creando un'immagine, decodificando un'immagine o ridimensionando un'immagine per adattarla all'ampia area dell'immagine di notifica, puoi ottenere le dimensioni corrette dei pixel in questo modo:

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

Notifica in corso con il pulsante Azione

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

Registrare un ricevitore di trasmissione per la stessa azione per gestire l'evento di clic del pulsante di azione.

Modified text is an extract of the original Stack Overflow Documentation

Autorizzato sotto CC BY-SA 3.0

Non affiliato con Stack Overflow

Android
notifiche

Ricerca…