Interactive Notification nelle app mobili: cosa sono, tipi e come funzionano

Cos'è Interactive Notification

Interactive Notification è un formato esteso di notifica push contenente controlli interattivi: pulsanti, interruttori e campi di input di testo. A differenza di una notifica standard che informa soltanto, una notifica interattiva consente all'utente di eseguire un'azione target direttamente dal pannello delle notifiche o dalla schermata di blocco. Secondo Google Material Design (2025), le notifiche interattive vengono elaborate dal sistema operativo senza avviare il processo principale dell'app — questo consente di risparmiare risorse della batteria e accelerare i tempi di risposta. Lo sviluppatore definisce un insieme di azioni tramite categorie su iOS e canali su Android, e il sistema le visualizza in base al contesto.

Struttura di una notifica interattiva

Ogni notifica interattiva è composta da tre livelli: contenuto principale (titolo, corpo), azioni (pulsanti) e input di testo opzionale. Su iOS, questi componenti vengono combinati tramite UNNotificationCategory, e su Android — tramite NotificationCompat.Action.Builder. Il sistema mostra i pulsanti sotto il testo della notifica in vista compressa o espansa a seconda della versione del sistema operativo e della lunghezza del testo. L'utente vede le azioni disponibili immediatamente dopo aver ricevuto la notifica e può eseguirne una senza passare all'app.

Come funzionano le notifiche interattive

Il meccanismo di funzionamento di Interactive Notification si divide in due fasi: registrazione delle categorie all'avvio dell'app e elaborazione dell'azione quando l'utente tocca. Nella fase di registrazione, lo sviluppatore crea oggetti categoria con un insieme di azioni — ogni azione ha un identificatore, un titolo e opzioni. Quando viene ricevuta una notifica push, il sistema la abbina alla categoria registrata tramite il campo categoryIdentifier e aggiunge automaticamente i pulsanti corrispondenti. Quando l'utente tocca un pulsante, il sistema chiama il delegato UNUserNotificationCenter o PendingIntent su Android con l'identificatore dell'azione e restituisce il risultato all'app. Secondo WWDC 2024, il tempo di elaborazione di un'azione interattiva su iOS non supera i 200 ms con una configurazione corretta.

Tipi di notifiche interattive

Le notifiche interattive si dividono in tre tipi principali in base al metodo di interazione: a pulsanti, testuali e multimediali. Ogni tipo risolve il proprio compito e viene utilizzato in scenari specifici. La scelta del tipo dipende dal contesto — meno passaggi sono richiesti all'utente, maggiore è la conversione. Apple e Google raccomandano di utilizzare pulsanti per la conferma, campi di input per le risposte e media per l'anteprima dei contenuti.

Pulsanti di azione

Il tipo più comune è una notifica con uno o più pulsanti, ciascuno dei quali esegue un'azione predefinita. Ad esempio, i pulsanti “Accetta” e “Rifiuta” per un evento del calendario, “Mi piace” e “Rispondi” per un messaggio. iOS supporta fino a quattro pulsanti, Android — fino a tre. I pulsanti possono essere raggruppati per priorità: normali e distruttivi (con conferma). Apple raccomanda non più di due pulsanti principali per la comodità dell'utente sulla schermata di blocco.

Input di testo

RemoteInput è una tecnologia che consente all'utente di inserire testo direttamente nella notifica senza aprire l'app. Su iOS viene utilizzato UNTextInputNotificationAction per questo scopo, su Android — RemoteInput.Builder con una chiave per estrarre il testo inserito. Viene utilizzato più spesso nelle app di messaggistica per rispondere rapidamente a un messaggio. Il testo inserito viene passato all'app tramite il servizio di notifiche o il gestore locale. Il limite è che il testo non può contenere formattazione, solo stringa semplice.

Contenuti multimediali

Le notifiche con allegati multimediali consentono di visualizzare immagini, audio e video direttamente nel pannello delle notifiche. Su iOS, questo viene implementato tramite UNNotificationAttachment, su Android — tramite NotificationCompat.MessagingStyle con BigPictureStyle. I media vengono caricati dal server del provider push e inviati insieme alla notifica come allegato. La dimensione dell'allegato è limitata — Apple raccomanda non più di 10 MB, Google — non più di 1 MB per le immagini. I contenuti multimediali aumentano l'informatività delle notifiche per notizie, marketplace e social network.

Implementazione su iOS

Su iOS, Interactive Notification viene implementata tramite il framework UserNotifications utilizzando UNNotificationCategory e UNNotificationAction. L'app registra le categorie all'avvio e, quando viene ricevuta una notifica, il sistema mostra automaticamente i pulsanti corrispondenti. Per gestire le azioni, è necessario implementare il metodo userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler. Di seguito è riportato un esempio di registrazione di una categoria con un pulsante e input di testo in Swift.

Registrazione delle categorie di notifica

import UserNotifications

let replyAction = UNTextInputNotificationAction(
    identifier: "reply",
    title: "Rispondi",
    options: [.authenticationRequired],
    textInputButtonTitle: "Invia",
    textInputPlaceholder: "Inserisci messaggio…"
)

let category = UNNotificationCategory(
    identifier: "message",
    actions: [replyAction],
    intentIdentifiers: [],
    options: []
)

UNUserNotificationCenter.current()
    .setNotificationCategories([category])

Dopo aver chiamato setNotificationCategories, il sistema salva le categorie e le utilizza per tutte le notifiche successive. Il codice deve essere chiamato a ogni avvio dell'app per sincronizzare le categorie con le nuove versioni. La gestione della risposta viene eseguita nel delegato del centro notifiche — l'app riceve l'identificatore dell'azione e il testo inserito per l'elaborazione successiva.

Gestione della pressione del pulsante

func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse,
    withCompletionHandler completion: @escaping VoidBlock
) {
    if response.actionIdentifier == "reply" {
        let textResponse = response as! UNTextInputNotificationResponse
        let message = textResponse.userText
        sendMessage(message)
    }
    completion()
}

Il metodo userNotificationCenter viene chiamato dal sistema dopo che l'utente ha toccato un pulsante o inviato testo. All'interno del gestore, viene verificato l'actionIdentifier — se corrisponde all'identificatore registrato, l'app estrae il testo inserito da userText e lo invia al server. Per i pulsanti normali senza input di testo, viene utilizzato UNNotificationResponse senza conversione di tipo.

Implementazione su Android

Su Android, le notifiche interattive vengono create tramite la classe NotificationCompat con i metodi addAction e RemoteInput. A differenza di iOS, Android non richiede la registrazione preventiva delle categorie — le azioni vengono aggiunte direttamente a ogni notifica tramite Builder. Questo offre maggiore flessibilità: ogni notifica può avere un insieme unico di pulsanti. Di seguito è riportato un esempio di notifica con un pulsante di risposta in Java che utilizza RemoteInput.

Creazione di una notifica con RemoteInput

RemoteInput remoteInput = new RemoteInput.Builder("key_reply")
    .setLabel("Rispondi")
    .build();

PendingIntent replyIntent = PendingIntent.getBroadcast(
    this, 1001,
    new Intent("ACTION_REPLY"),
    PendingIntent.FLAG_UPDATE_CURRENT
);

NotificationCompat.Action action =
    new NotificationCompat.Action.Builder(
        R.drawable.ic_reply,
        "Rispondi", replyIntent
    )
    .addRemoteInput(remoteInput)
    .build();

NotificationCompat.Builder builder =
    new NotificationCompat.Builder(this, "messages")
    .setContentTitle("Nuovo messaggio")
    .setContentText("Ciao! Come stai?")
    .setSmallIcon(R.drawable.ic_notification)
    .addAction(action);

NotificationManagerCompat.from(this)
    .notify(100, builder.build());

L'elemento chiave è RemoteInput, che collega il campo di input all'azione. Quando l'utente tocca il pulsante “Rispondi”, il sistema apre una finestra di dialogo di input testo all'interno della notifica. Dopo l'invio, il testo viene passato tramite Intent a un BroadcastReceiver o Activity tramite il PendingIntent specificato. Per ottenere il testo nel ricevitore, viene utilizzato RemoteInput.getResultsFromIntent(intent) con la chiave “key_reply”.

Estrazione del testo inserito

Bundle results = RemoteInput.getResultsFromIntent(intent);
if (results != null) {
    CharSequence reply = results.getCharSequence("key_reply");
    if (reply != null) {
        sendReplyToServer(reply.toString());
    }
}

Il metodo getResultsFromIntent estrae il testo inserito dall'utente dall'Intent passato dal sistema all'invio della risposta. Il risultato viene restituito come CharSequence, che viene convertito in una stringa per l'invio al server. Se l'utente ha chiuso la finestra di dialogo senza inviare, results sarà vuoto — questo deve essere considerato durante l'elaborazione. Questo approccio consente di implementare una risposta rapida senza avviare un'Activity.

Casi d'uso

Interactive Notification viene utilizzata in applicazioni di qualsiasi tipo dove è richiesta un'azione rapida dell'utente. Gli scenari più efficaci sono i messenger per rispondere a un messaggio, l'e-commerce per la conferma dell'ordine e i calendari per accettare un invito. Secondo Localytics (2025), le app con notifiche interattive mostrano una retention del 28% più alta al 7º giorno. Di seguito è riportata una tabella con scenari popolari e caratteristiche della piattaforma.

Quando si progettano notifiche interattive, è importante considerare il limite — l'utente può eseguire un'azione solo una volta. Dopo aver premuto un pulsante, la notifica scompare o passa allo stato “completato”. Pertanto, ogni azione dovrebbe essere irreversibile o avere una conferma al secondo passaggio.