Crea una notifica

Le notifiche forniscono informazioni brevi e tempestive sugli eventi nella tua app quando non è in uso. Questo documento mostra come creare una notifica con varie funzionalità. Per un'introduzione a come vengono visualizzate le notifiche su Android, consulta la panoramica delle notifiche. Per il codice campione che utilizza le notifiche, consulta l'esempio SociaLite su GitHub.

Il codice in questa pagina utilizza le NotificationCompat API della libreria AndroidX. Queste API ti consentono di aggiungere funzionalità disponibili solo nelle versioni più recenti di Android, pur mantenendo la compatibilità con Android 9 (livello API 28). Tuttavia, alcune funzionalità, come l'azione di risposta in linea, comportano un'operazione no-op nelle versioni precedenti.

Creare una notifica di base

Una notifica nella sua forma più semplice e compatta, nota anche come compressa forma, mostra un'icona, un titolo e una piccola quantità di contenuti di testo. Questa sezione mostra come creare una notifica che l'utente può toccare per avviare un'attività nella tua app.

Figura 1. Una notifica con un'icona, un titolo e del testo.

Per maggiori dettagli su ogni parte di una notifica, consulta la sezione Anatomia delle notifiche.

Dichiarare l'autorizzazione di runtime

Android 13 (livello API 33) e versioni successive supportano un'autorizzazione di runtime per la pubblicazione di notifiche non esenti (inclusi i servizi in primo piano (FGS)) da un'app.

L'autorizzazione che devi dichiarare nel file manifest della tua app è riportata nel seguente snippet di codice:

<manifest ...>
    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
    <application ...>
        ...
    </application>
</manifest>

Per maggiori dettagli sulle autorizzazioni di runtime, consulta Autorizzazione di runtime per le notifiche.

Impostare i contenuti delle notifiche

Per iniziare, imposta i contenuti e il canale della notifica utilizzando un NotificationCompat.Builder oggetto. L'esempio seguente mostra come creare una notifica con:

• Una piccola icona, impostata da setSmallIcon(). Questi sono gli unici contenuti visibili all'utente richiesti.

• Un titolo, impostato da setContentTitle().

• Il testo del corpo, impostato da setContentText().

• La priorità della notifica, impostata da setPriority(). La priorità determina il livello di intrusività della notifica su Android 7.1 e versioni precedenti. Per Android 8.0 e versioni successive, imposta invece l'importanza del canale come mostrato nella sezione successiva.

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle(textTitle)
        .setContentText(textContent)
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle(textTitle)
        .setContentText(textContent)
        .setPriority(NotificationCompat.PRIORITY_DEFAULT);

Il costruttore NotificationCompat.Builder richiede di fornire un ID canale. Questo è necessario per la compatibilità con Android 8.0 (livello API 26) e versioni successive, ma viene ignorato dalle versioni precedenti.

Per impostazione predefinita, i contenuti di testo della notifica vengono troncati per adattarsi a una riga. Puoi mostrare ulteriori informazioni creando una notifica espandibile.

Figura 2. Una notifica espandibile nelle sue forme compressa ed espansa.

Se vuoi che la notifica sia più lunga, puoi abilitare una notifica espandibile aggiungendo un modello di stile con setStyle(). Ad esempio, il seguente codice crea un'area di testo più grande:

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Much longer text that cannot fit one line...")
        <b>.setStyle(NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))</b>
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Much longer text that cannot fit one line...")
        <b>.setStyle(new NotificationCompat.BigTextStyle()
                .bigText("Much longer text that cannot fit one line..."))</b>
        .setPriority(NotificationCompat.PRIORITY_DEFAULT);

Per ulteriori informazioni su altri stili di notifiche di grandi dimensioni, incluso come aggiungere un'immagine e i controlli di riproduzione multimediale, consulta Creare una notifica espandibile.

Creare un canale e impostare l'importanza

Prima di poter inviare la notifica su Android 8.0 e versioni successive, registra il canale di notifica della tua app con il sistema passando un'istanza di NotificationChannel a createNotificationChannel(). Il seguente codice è bloccato da una condizione sulla SDK_INT versione:

private fun createNotificationChannel() {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is not in the Support Library.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val name = getString(R.string.channel_name)
        val descriptionText = getString(R.string.channel_description)
        val importance = NotificationManager.IMPORTANCE_DEFAULT
        val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
            description = descriptionText
        }
        // Register the channel with the system.
        val notificationManager: NotificationManager =
            getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        notificationManager.createNotificationChannel(channel)
    }
}

private void createNotificationChannel() {
    // Create the NotificationChannel, but only on API 26+ because
    // the NotificationChannel class is not in the Support Library.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        CharSequence name = getString(R.string.channel_name);
        String description = getString(R.string.channel_description);
        int importance = NotificationManager.IMPORTANCE_DEFAULT;
        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
        channel.setDescription(description);
        // Register the channel with the system; you can't change the importance
        // or other notification behaviors after this.
        NotificationManager notificationManager = getSystemService(NotificationManager.class);
        notificationManager.createNotificationChannel(channel);
    }
}

Poiché devi creare il canale di notifica prima di pubblicare le notifiche su Android 8.0 e versioni successive, esegui questo codice non appena viene avviata l'app. È sicuro chiamare questo codice ripetutamente, perché la creazione di un canale di notifica esistente non esegue alcuna operazione.

Il costruttore NotificationChannel richiede un'importance, utilizzando una delle costanti della classe NotificationManager. Questo parametro determina come interrompere l'utente per qualsiasi notifica appartenente a questo canale. Imposta la priorità con setPriority() per supportare Android 7.1 e versioni precedenti, come mostrato nell'esempio precedente.

Sebbene tu debba impostare l'importanza o la priorità della notifica come mostrato nell'esempio seguente, il sistema non garantisce il comportamento di avviso che ottieni. In alcuni casi, il sistema potrebbe modificare il livello di importanza in base ad altri fattori e l'utente può sempre ridefinire il livello di importanza per un determinato canale.

Per ulteriori informazioni sul significato dei diversi livelli, consulta Livelli di importanza delle notifiche.

Impostare l'azione di tocco della notifica

Ogni notifica deve rispondere a un tocco, in genere per aprire un'attività nella tua app corrispondente alla notifica. Per farlo, specifica un intent di contenuti definito con un PendingIntent oggetto e passalo a setContentIntent().

Il seguente snippet mostra come creare un intent di base per aprire un'attività quando l'utente tocca la notifica:

// Create an explicit intent for an Activity in your app.
<b>val intent = Intent(this, AlertDetails::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}</b>
val pendingIntent: PendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE)

val builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        // Set the intent that fires when the user taps the notification.
        <b>.setContentIntent(pendingIntent)</b>
        .setAutoCancel(true)

// Create an explicit intent for an Activity in your app.
<b>Intent intent = new Intent(this, AlertDetails.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);</b>
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_IMMUTABLE);

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        // Set the intent that fires when the user taps the notification.
        <b>.setContentIntent(pendingIntent)</b>
        .setAutoCancel(true);

Questo codice chiama setAutoCancel(), che rimuove automaticamente la notifica quando l'utente la tocca.

I flag di intent nell'esempio precedente mantengono l'esperienza di navigazione prevista dall'utente dopo che l'utente apre l'app utilizzando la notifica. Potresti volerlo utilizzare a seconda del tipo di attività che stai avviando, che può essere una delle seguenti:

• Un'attività che esiste esclusivamente per le risposte alla notifica. Non c'è motivo per cui l'utente navighi a questa attività durante il normale utilizzo dell'app, quindi l'attività avvia una nuova attività anziché essere aggiunta all'attività esistente e allo stack Back della tua app. Questo è il tipo di intent creato nell'esempio precedente.

• Un'attività che esiste nel normale flusso dell'app. In questo caso, l'avvio dell'attività crea uno stack Back in modo che le aspettative dell'utente per i pulsanti Indietro e Su vengano mantenute.

Per ulteriori informazioni sui diversi modi per configurare l'intent della notifica, consulta Avviare un'attività da una notifica.

Mostrare la notifica

Per visualizzare la notifica, chiama NotificationManagerCompat.notify(), passandogli un ID univoco per la notifica e il risultato di NotificationCompat.Builder.build(). Questo è mostrato nell'esempio seguente:

with(NotificationManagerCompat.from(this)) {
    if (ActivityCompat.checkSelfPermission(
            this@MainActivity,
            Manifest.permission.POST_NOTIFICATIONS
        ) != PackageManager.PERMISSION_GRANTED
    ) {
        // TODO: Consider calling
        // ActivityCompat#requestPermissions
        // here to request the missing permissions, and then overriding
        // public fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>,
        //                                        grantResults: IntArray)
        // to handle the case where the user grants the permission. See the documentation
        // for ActivityCompat#requestPermissions for more details.

        return@with
    }
    // notificationId is a unique int for each notification that you must define.
    notify(NOTIFICATION_ID, builder.build())
}

if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
    // TODO: Consider calling
    // ActivityCompat#requestPermissions
    // here to request the missing permissions, and then overriding
    // public void onRequestPermissionsResult(int requestCode, String[] permissions,
    //                                        int[] grantResults)
    // to handle the case where the user grants the permission. See the documentation
    // for ActivityCompat#requestPermissions for more details.
    return;
}
NotificationManagerCompat.from(this).notify(NOTIFICATION_ID, builder.build());

Salva l'ID notifica che passi a NotificationManagerCompat.notify(), perché ti servirà quando vuoi aggiornare o rimuovere la notifica.

Inoltre, per testare le notifiche di base sui dispositivi con Android 13 e versioni successive, attiva le notifiche manualmente o crea una finestra di dialogo per richiedere le notifiche.

Aggiungere pulsanti di azione

Una notifica può offrire fino a tre pulsanti di azione che consentono all'utente di rispondere rapidamente, ad esempio per posticipare un promemoria o rispondere a un messaggio. Tuttavia, questi pulsanti di azione non devono duplicare l'azione eseguita quando l'utente tocca la notifica.

Figura 3. Una notifica con un pulsante di azione.

Per aggiungere un pulsante di azione, passa un PendingIntent al addAction() metodo. È come configurare l'azione di tocco predefinita della notifica, tranne che, anziché avviare un'attività, puoi fare altre cose, ad esempio avviare un BroadcastReceiver che esegue un job in background in modo che l' azione non interrompa l'app già aperta.

Ad esempio, il seguente codice mostra come inviare una trasmissione a un ricevitore specifico:

val ACTION_SNOOZE = "snooze"

<b>val snoozeIntent = Intent(this, MyBroadcastReceiver::class.java).apply {
    action = ACTION_SNOOZE
    putExtra(EXTRA_NOTIFICATION_ID, 0)
}
val snoozePendingIntent: PendingIntent =
    PendingIntent.getBroadcast(this, 0, snoozeIntent, 0)</b>
val builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        <b>.addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                snoozePendingIntent)</b>

String ACTION_SNOOZE = "snooze"

<b>Intent snoozeIntent = new Intent(this, MyBroadcastReceiver.class);
snoozeIntent.setAction(ACTION_SNOOZE);
snoozeIntent.putExtra(EXTRA_NOTIFICATION_ID, 0);
PendingIntent snoozePendingIntent =
        PendingIntent.getBroadcast(this, 0, snoozeIntent, 0);</b>

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        .setContentIntent(pendingIntent)
        <b>.addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                snoozePendingIntent);</b>

Per ulteriori informazioni sulla creazione di un BroadcastReceiver per eseguire il lavoro in background, consulta la panoramica delle trasmissioni.

Se invece stai cercando di creare una notifica con pulsanti di riproduzione multimediale, ad esempio per mettere in pausa e saltare le tracce, consulta la sezione su come creare una notifica con i controlli multimediali.

Aggiungere un'azione di risposta diretta

L'azione di risposta diretta, introdotta in Android 7.0 (livello API 24), consente agli utenti di inserire testo direttamente nella notifica. Il testo viene quindi inviato alla tua app senza aprire un'attività. Ad esempio, puoi utilizzare un'azione di risposta diretta per consentire agli utenti di rispondere ai messaggi o aggiornare gli elenchi di attività dall'interno della notifica.

Figura 4. Toccando il pulsante "Rispondi" si apre l'input di testo.

L'azione di risposta diretta viene visualizzata come un pulsante aggiuntivo nella notifica che apre un input di testo. Quando l'utente finisce di digitare, il sistema allega la risposta di testo all'intent specificato per l'azione di notifica e invia l'intent alla tua app.

Aggiungere il pulsante Rispondi

Per creare un'azione di notifica che supporti la risposta diretta:

1. Crea un'istanza di RemoteInput.Builder che puoi aggiungere all'azione di notifica. Il costruttore di questa classe accetta una stringa che il sistema utilizza come chiave per l'input di testo. La tua app utilizza in un secondo momento questa chiave per recuperare il testo dell'input. * {Kotlin} ```kotlin // Key for the string that's delivered in the action's intent. private val KEY_TEXT_REPLY = "key_text_reply" var replyLabel: String = resources.getString(R.string.reply_label) var remoteInput: RemoteInput = RemoteInput.Builder(KEY_TEXT_REPLY).run { setLabel(replyLabel) build() } ``` * {Java} ```java // Key for the string that's delivered in the action's intent. private static final String KEY_TEXT_REPLY = "key_text_reply"; String replyLabel = getResources().getString(R.string.reply_label); RemoteInput remoteInput = new RemoteInput.Builder(KEY_TEXT_REPLY) .setLabel(replyLabel) .build(); ```
2. Crea un PendingIntent per l'azione di risposta. * {Kotlin} ```kotlin // Build a PendingIntent for the reply action to trigger. var replyPendingIntent: PendingIntent = PendingIntent.getBroadcast(applicationContext, conversation.getConversationId(), getMessageReplyIntent(conversation.getConversationId()), PendingIntent.FLAG_UPDATE_CURRENT) ``` * {Java} ```java // Build a PendingIntent for the reply action to trigger. PendingIntent replyPendingIntent = PendingIntent.getBroadcast(getApplicationContext(), conversation.getConversationId(), getMessageReplyIntent(conversation.getConversationId()), PendingIntent.FLAG_UPDATE_CURRENT); ```
3. Collega l' RemoteInput oggetto a un'azione utilizzando addRemoteInput(). * {Kotlin} ```kotlin // Create the reply action and add the remote input. var action: NotificationCompat.Action = NotificationCompat.Action.Builder(R.drawable.ic_reply_icon, getString(R.string.label), replyPendingIntent) .addRemoteInput(remoteInput) .build() ``` * {Java} ```java // Create the reply action and add the remote input. NotificationCompat.Action action = new NotificationCompat.Action.Builder(R.drawable.ic_reply_icon, getString(R.string.label), replyPendingIntent) .addRemoteInput(remoteInput) .build(); ```
4. Applica l'azione a una notifica e invia la notifica. * {Kotlin} ```kotlin // Build the notification and add the action. val newMessageNotification = Notification.Builder(context, CHANNEL_ID) .setSmallIcon(R.drawable.ic_message) .setContentTitle(getString(R.string.title)) .setContentText(getString(R.string.content)) .addAction(action) .build() // Issue the notification. with(NotificationManagerCompat.from(this)) { notificationManager.notify(notificationId, newMessageNotification) } ``` * {Java} ```java // Build the notification and add the action. Notification newMessageNotification = new Notification.Builder(context, CHANNEL_ID) .setSmallIcon(R.drawable.ic_message) .setContentTitle(getString(R.string.title)) .setContentText(getString(R.string.content)) .addAction(action) .build(); // Issue the notification. NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this); notificationManager.notify(notificationId, newMessageNotification); ```

Il sistema chiede all'utente di inserire una risposta quando attiva l'azione di notifica, come mostrato nella Figura 4.

Recuperare l'input dell'utente dalla risposta

Per ricevere l'input dell'utente dall'interfaccia utente di risposta della notifica, chiama RemoteInput.getResultsFromIntent(), passandogli il Intent ricevuto da tuo BroadcastReceiver:

private fun getMessageText(intent: Intent): CharSequence? {
    return RemoteInput.getResultsFromIntent(intent)?.getCharSequence(KEY_TEXT_REPLY)
}

private CharSequence getMessageText(Intent intent) {
    Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
    if (remoteInput != null) {
        return remoteInput.getCharSequence(KEY_TEXT_REPLY);
    }
    return null;
 }

Dopo aver elaborato il testo, aggiorna la notifica chiamando NotificationManagerCompat.notify() con lo stesso ID e tag, se utilizzato. Questa operazione è necessaria per nascondere l'interfaccia utente di risposta diretta e confermare all'utente che la sua risposta è stata ricevuta ed elaborata correttamente.

// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
val repliedNotification = Notification.Builder(context, CHANNEL_ID)
        .setSmallIcon(R.drawable.ic_message)
        .setContentText(getString(R.string.replied))
        .build()

// Issue the new notification.
NotificationManagerCompat.from(this).apply {
    notificationManager.notify(notificationId, repliedNotification)
}

// Build a new notification, which informs the user that the system
// handled their interaction with the previous notification.
Notification repliedNotification = new Notification.Builder(context, CHANNEL_ID)
        .setSmallIcon(R.drawable.ic_message)
        .setContentText(getString(R.string.replied))
        .build();

// Issue the new notification.
NotificationManagerCompat notificationManager = NotificationManagerCompat.from(this);
notificationManager.notify(notificationId, repliedNotification);

Recuperare altri dati

La gestione di altri tipi di dati funziona in modo simile con RemoteInput. L'esempio seguente utilizza l'immagine come input.

  // Key for the data that's delivered in the action's intent.
  private val KEY_REPLY = "key_reply"
  var replyLabel: String = resources.getString(R.string.reply_label)
  var remoteInput: RemoteInput = RemoteInput.Builder(KEY_REPLY).run {
      setLabel(replyLabel)
      // Allow for image data types in the input
  // This method can be used again to
  // allow for other data types
      setAllowDataType("image/*", true)
      build()
}

Chiama RemoteInput#getDataResultsFromIntent ed estrai i dati corrispondenti.

  import android.app.RemoteInput;
  import android.content.Intent;
  import android.os.Bundle;

  class ReplyReceiver: BroadcastReceiver()  {

      public static final String KEY_DATA = "key_data";

      public static void handleRemoteInput(Intent intent) {
          Bundle dataResults = RemoteInput.getDataResultsFromIntent(intent, KEY_DATA);
          val imageUri: Uri? = dataResults.values.firstOrNull()
          if (imageUri != null) {
              // Extract the image
          try {
                  val inputStream = context.contentResolver.openInputStream(imageUri)
                  val bitmap = BitmapFactory.decodeStream(inputStream)
                  // Display the image
                  // ...
              } catch (e: Exception) {
                  Log.e("ReplyReceiver", "Failed to process image URI", e)
              }
      }
  }

Quando lavori con questa nuova notifica, utilizza il contesto passato al metodo onReceive() del ricevitore.

Aggiungi la risposta in fondo alla notifica chiamando setRemoteInputHistory(). Tuttavia, se stai creando un'app di messaggistica, crea una notifica in stile messaggistica e aggiungi il nuovo messaggio alla conversazione.

Per ulteriori suggerimenti sulle notifiche delle app di messaggistica, consulta la sezione sulle best practice per le app di messaggistica.

Mostrare un messaggio urgente

La tua app potrebbe dover mostrare un messaggio urgente e sensibile al tempo, ad esempio una chiamata in arrivo o una sveglia che suona. In queste situazioni, puoi associare un intent a schermo intero alla notifica.

Quando viene richiamata la notifica, gli utenti vedono una delle seguenti opzioni, a seconda dello stato di blocco del dispositivo:

• Se il dispositivo dell'utente è bloccato, viene visualizzata un'attività a schermo intero che copre la schermata di blocco.
• Se il dispositivo dell'utente è sbloccato, la notifica viene visualizzata in forma espansa che include opzioni per gestire o ignorare la notifica.

Il seguente snippet di codice mostra come associare la notifica a un intent a schermo intero:

val fullScreenIntent = Intent(this, ImportantActivity::class.java)
val fullScreenPendingIntent = PendingIntent.getActivity(this, 0,
    fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT)

var builder = NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        <b>.setFullScreenIntent(fullScreenPendingIntent, true)</b>

Intent fullScreenIntent = new Intent(this, ImportantActivity.class);
PendingIntent fullScreenPendingIntent = PendingIntent.getActivity(this, 0,
        fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT);

NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
        .setSmallIcon(R.drawable.notification_icon)
        .setContentTitle("My notification")
        .setContentText("Hello World!")
        .setPriority(NotificationCompat.PRIORITY_DEFAULT)
        <b>.setFullScreenIntent(fullScreenPendingIntent, true);</b>

Impostare la visibilità della schermata di blocco

Per controllare il livello di dettaglio visibile nella notifica dalla schermata di blocco, chiama setVisibility() e specifica uno dei seguenti valori:

• VISIBILITY_PUBLIC: i contenuti completi della notifica vengono visualizzati sulla schermata di blocco.

• VISIBILITY_SECRET: nessuna parte della notifica viene visualizzata sulla schermata di blocco.

• VISIBILITY_PRIVATE: sulla schermata di blocco vengono visualizzate solo le informazioni di base, come l'icona della notifica e il titolo dei contenuti. I contenuti completi della notifica non vengono visualizzati.

Quando imposti VISIBILITY_PRIVATE, puoi anche fornire una versione alternativa dei contenuti della notifica che nasconde determinati dettagli. Ad esempio, un'app per SMS potrebbe visualizzare una notifica che mostra "Hai 3 nuovi messaggi", ma nasconde i contenuti dei messaggi e i mittenti. Per fornire questa notifica alternativa, crea prima la notifica alternativa con NotificationCompat.Builder come di consueto. Poi, collega la notifica alternativa alla notifica normale con setPublicVersion().

Tieni presente che l'utente ha sempre il controllo finale sulla visibilità delle notifiche sulla schermata di blocco e può controllarle in base ai canali di notifica della tua app.

Aggiornare una notifica

Per aggiornare una notifica dopo averla inviata, chiama di nuovo NotificationManagerCompat.notify(), passandogli lo stesso ID utilizzato in precedenza. Se la notifica precedente viene ignorata, viene creata una nuova notifica.

Facoltativamente, puoi chiamare setOnlyAlertOnce() in modo che la notifica interrompa l'utente (con suoni, vibrazioni o indizi visivi) solo la prima volta che viene visualizzata e non per gli aggiornamenti successivi.

Rimuovere una notifica

Le notifiche rimangono visibili finché non si verifica una delle seguenti condizioni:

• L'utente ignora la notifica.
• L'utente tocca la notifica, se chiami setAutoCancel() quando crei la notifica.
• Chiami cancel() per un ID notifica specifico. Questo metodo elimina anche le notifiche in corso.
• Chiami cancelAll(), che rimuove tutte le notifiche inviate in precedenza.
• Trascorre la durata specificata, se imposti un timeout durante la creazione della notifica utilizzando setTimeoutAfter(). Se necessario, puoi annullare una notifica prima che trascorra la durata del timeout specificata.

Best practice per le app di messaggistica

Quando crei notifiche per le tue app di messaggistica e chat, tieni presente le best practice elencate qui.

Utilizzare MessagingStyle

A partire da Android 7.0 (livello API 24), Android fornisce un modello di stile di notifica specifico per i contenuti di messaggistica. Utilizzando la NotificationCompat.MessagingStyle classe, puoi modificare diverse etichette visualizzate nella notifica, tra cui il titolo della conversazione, messaggi aggiuntivi e la visualizzazione dei contenuti della notifica.

Il seguente snippet di codice mostra come personalizzare lo stile di una notifica utilizzando la classe MessagingStyle.

val user = Person.Builder()
    .setIcon(userIcon)
    .setName(userName)
    .build()

val notification = NotificationCompat.Builder(this, CHANNEL_ID)
    .setContentTitle("2 new messages with $sender")
    .setContentText(subject)
    .setSmallIcon(R.drawable.new_message)
    .setStyle(NotificationCompat.MessagingStyle(user)
        .addMessage(messages[1].getText(), messages[1].getTime(), messages[1].getPerson())
        .addMessage(messages[2].getText(), messages[2].getTime(), messages[2].getPerson())
    )
    .build()

Person user = new Person.Builder()
    .setIcon(userIcon)
    .setName(userName)
    .build();

Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
    .setContentTitle("2 new messages with " + sender)
    .setContentText(subject)
    .setSmallIcon(R.drawable.new_message)
    .setStyle(new NotificationCompat.MessagingStyle(user)
        .addMessage(messages[1].getText(), messages[1].getTime(), messages[1].getPerson())
        .addMessage(messages[2].getText(), messages[2].getTime(), messages[2].getPerson())
    )
    .build();

A partire da Android 9.0 (livello API 28), è anche necessario utilizzare la Person classe per ottenere un rendering ottimale della notifica e dei relativi avatar.

Quando utilizzi NotificationCompat.MessagingStyle:

• Chiama MessagingStyle.setConversationTitle() per impostare un titolo per le chat di gruppo con più di due persone. Un buon titolo di conversazione potrebbe essere il nome della chat di gruppo o, se non ha un nome, un elenco dei partecipanti alla conversazione. In caso contrario, il messaggio potrebbe essere scambiato per una conversazione 1:1 con il mittente del messaggio più recente nella conversazione.
• Utilizza il MessagingStyle.setData() metodo per includere messaggi multimediali come le immagini. Sono supportati i tipi MIME dell'immagine del pattern/*.

Utilizzare la risposta diretta

La risposta diretta consente a un utente di rispondere in linea a un messaggio.

• Dopo che un utente ha risposto con l'azione di risposta in linea, utilizza MessagingStyle.addMessage() per aggiornare la MessagingStyle notifica e non ritirare o annullare la notifica. Se non annulli la notifica, l'utente può inviare più risposte dalla notifica.
• Per rendere l'azione di risposta in linea compatibile con Wear OS, chiama Action.WearableExtender.setHintDisplayInlineAction(true).
• Utilizza il addHistoricMessage() metodo per fornire il contesto a una conversazione di risposta diretta aggiungendo messaggi storici alla notifica.

Attivare la risposta rapida

• Per attivare la risposta rapida, chiama setAllowGeneratedResponses(true) sull' azione di risposta. In questo modo, le risposte rapide saranno disponibili per gli utenti quando la notifica viene trasferita a un dispositivo Wear OS. Le risposte rapide vengono generate da un modello di machine learning interamente sull'orologio utilizzando il contesto fornito dalla notifica NotificationCompat.MessagingStyle e non vengono caricati dati su internet per generare le risposte.

Aggiungere metadati di notifica

• Assegna i metadati di notifica per indicare al sistema come gestire le notifiche dell'app quando il dispositivo è in Do Not Disturb mode. Ad esempio, utilizza il addPerson() o setCategory(Notification.CATEGORY_MESSAGE) metodo per ignorare Non disturbare.