Notification Action nelle app mobili: cosa sono, varietà e configurazione

Cosa sono le Notification Action

Notification Action è un elemento interattivo dell'interfaccia aggiunto a una notifica push per eseguire un'azione specifica. L'utente può rispondere a un messaggio, confermare un'attività o aprire una schermata specifica senza entrare nell'app. Le azioni appaiono come pulsanti sotto il testo della notifica o in una vista espansa durante lo swipe.

Perché servono azioni nelle notifiche

L'obiettivo principale di Notification Action è ridurre il numero di passaggi per raggiungere l'obiettivo dell'utente. Invece di aprire l'app e navigare verso la schermata desiderata, l'utente preme un singolo pulsante. Le ricerche mostrano che le app con notifiche interattive mostrano un coinvolgimento del 25–40% superiore rispetto alle notifiche semplici.

Rappresentazione visiva su diverse piattaforme

Su Android, le Notification Action vengono visualizzate come pulsanti icona in vista compatta e pulsanti di testo in modalità espandibile. Su iOS, le azioni appaiono con una pressione prolungata sulla notifica o con uno swipe a sinistra. Ogni piattaforma ha le proprie raccomandazioni sul numero di azioni — Android raccomanda non più di 3, iOS non più di 4.

Notification Action su Android

Su Android, le Notification Action vengono create tramite NotificationCompat.Builder utilizzando il metodo addAction(). Ogni azione contiene un'icona, testo e PendingIntent che si attiva al tocco. A partire da Android 7.0 (API 24), l'input diretto di testo tramite RemoteInput è supportato.

Creazione di un'azione base

Per creare un pulsante in una notifica, è necessario definire un PendingIntent che verrà avviato al tocco. PendingIntent può aprire un'Activity, avviare un Service o un BroadcastReceiver. L'icona dell'azione deve essere monocromatica e conforme a Material Design.

val acceptIntent = Intent(context, AcceptActionReceiver::class.java)
acceptIntent.putExtra("notification_id", notificationId)

val acceptPendingIntent = PendingIntent.getBroadcast(
    context, requestCode,
    acceptIntent, PendingIntent.FLAG_UPDATE_CURRENT
)

val notification = NotificationCompat.Builder(context, CHANNEL_ID)
    .setSmallIcon(R.drawable.ic_notification)
    .setContentTitle("Richiesta di conferma")
    .setContentText("Conferma il completamento dell'attività")
    .addAction(R.drawable.ic_accept, "Conferma", acceptPendingIntent)
    .build()

Azione con input di testo (RemoteInput)

Per scenari che richiedono input di testo (ad esempio, rispondere a un messaggio), Android fornisce RemoteInput. L'utente inserisce il testo direttamente nella notifica e l'app lo riceve senza aprire un'Activity. RemoteInput è supportato su Android 7.0+ e richiede una gestione esplicita in un BroadcastReceiver o Service.

val remoteInput = RemoteInput.Builder("reply_input")
    .setLabel("Inserisci risposta")
    .build()

val replyAction = NotificationCompat.Action.Builder(
    R.drawable.ic_reply, "Rispondi", replyPendingIntent
)
    .addRemoteInput(remoteInput)
    .build()

val notification = NotificationCompat.Builder(context, CHANNEL_ID)
    .addAction(replyAction)
    .build()

Gestione delle azioni su Android

Quando un'azione viene toccata, il sistema avvia il PendingIntent specificato. Per recuperare il testo inserito tramite RemoteInput, chiamare RemoteInput.getResultsFromIntent(intent). Si consiglia di gestire le azioni in IntentService o WorkManager per non bloccare il thread dell'interfaccia utente.

Notification Action su iOS

Su iOS, le Notification Action sono implementate tramite il framework UserNotifications. Lo sviluppatore crea categorie di azioni (UNNotificationCategory) e le registra all'avvio dell'app. Ogni azione è definita da un oggetto UNNotificationAction con un identificatore univoco.

Configurazione di categorie e azioni su iOS

Per aggiungere azioni alle notifiche push su iOS, è necessario creare una categoria che raggruppa le azioni correlate. La categoria viene specificata nel payload della notifica tramite il campo category. Al ricevimento di una notifica, il sistema mostra le azioni disponibili dalla categoria specificata.

import UserNotifications

class NotificationSetup {

    func registerNotificationCategories() {
        let approveAction = UNNotificationAction(
            identifier: "APPROVE_ACTION",
            title: "Approva",
            options: [.foreground]
        )

        let declineAction = UNNotificationAction(
            identifier: "DECLINE_ACTION",
            title: "Rifiuta",
            options: [.destructive]
        )

        let category = UNNotificationCategory(
            identifier: "REQUEST_CATEGORY",
            actions: [approveAction, declineAction],
            intentIdentifiers: [],
            options: []
        )

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

Gestione delle azioni su iOS

Quando l'utente tocca un'azione, il sistema chiama il metodo userNotificationCenter:didReceiveNotificationResponse nel delegato di UNUserNotificationCenter. response.actionIdentifier contiene l'identificatore dell'azione eseguita. Per l'input di testo, viene utilizzato UNTextInputNotificationAction, che fornisce il testo inserito dall'utente.

extension AppDelegate: UNUserNotificationCenterDelegate {

    func userNotificationCenter(
        center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        switch response.actionIdentifier {
        case "APPROVE_ACTION":
            Log.d("Action: approved")
        case "DECLINE_ACTION":
            Log.d("Action: declined")
        case UNNotificationDefaultActionIdentifier:
            Log.d("Action: opened app")
        default:
            break
        }
        completionHandler()
    }
}

Tipi e scenari di Notification Action

Notification Action è classificata per tipo di interazione e scenario d'uso. La scelta corretta del tipo di azione influisce direttamente sull'esperienza utente e sulla conversione verso l'azione target.

Pulsanti con apertura dell'app

Il tipo più comune — un pulsante che apre l'app su una schermata specifica. Su Android, si usa PendingIntent.getActivity(), su iOS — l'opzione .foreground di UNNotificationAction. Utilizzato per azioni che richiedono un'interfaccia completa, come visualizzare i dettagli dell'ordine.

Azioni in background

Azioni che vengono eseguite senza aprire l'app. Su Android, si usa PendingIntent.getBroadcast() o PendingIntent.getService(). Su iOS — l'opzione .authenticationRequired o senza .foreground. Esempi: contrassegnare attività come completata, mettere mi piace a un post, aggiungere ai preferiti.

Input di testo

Consente all'utente di inserire testo direttamente nella notifica. Su Android, implementato tramite RemoteInput, su iOS — tramite UNTextInputNotificationAction. Utilizzato per rispondere a messaggi, commenti, inserire codici di conferma monouso.

Azioni distruttive

Azioni che modificano i dati in modo irreversibile — eliminazione, rifiuto, blocco. Su Android, sono evidenziate visivamente (colore rosso in alcuni sistemi), su iOS richiedono l'opzione .destructive. Si consiglia di richiedere conferma per azioni distruttive, ad esempio tramite un dialogo aggiuntivo o un secondo tocco.

Azioni di input con inserimento testo

Una classe separata di azioni — inserimento di testo direttamente dalla notifica. Su Android, questo è implementato tramite RemoteInput in combinazione con PendingIntent. Su iOS, viene utilizzato UNTextInputNotificationAction, che eredita da UNNotificationAction. Tali azioni vengono utilizzate per risposte rapide nei messenger, inserimento di codici promozionali, compilazione di moduli di feedback o valutazione della qualità del servizio. Il testo inserito viene passato all'app insieme all'identificatore dell'azione. Per una corretta gestione dell'input di testo su entrambe le piattaforme, è necessario implementare l'analisi dei dati inseriti e la validazione prima di eseguire l'azione target.

Gestione tocchi e registrazione

La corretta gestione di Notification Action è fondamentale per l'analisi e l'esperienza utente. Ogni tocco deve essere registrato e l'azione deve essere eseguita in modo affidabile anche se l'app era chiusa.

Analisi e monitoraggio

Traccia ogni tocco su Notification Action attraverso il tuo sistema di analisi. Firebase Analytics, Mixpanel o Yandex.Metrica consentono di registrare l'identificatore dell'azione, l'ora del tocco e il contesto della notifica. Questi dati aiutano a ottimizzare la strategia delle notifiche e aumentare il coinvolgimento. I test A/B con diversi set di azioni aiutano a identificare gli scenari di interazione più efficaci con l'utente.

Gestione affidabile quando l'app è chiusa

Se l'app è chiusa, il sistema consegna comunque l'Intent o UNNotificationResponse al tocco di un'azione. Su Android, utilizzare un BroadcastReceiver per una gestione garantita. Su iOS, il sistema avvia l'app in background e passa la risposta al delegato. Per azioni critiche (conferma di pagamento, autorizzazione), aggiungere un meccanismo di ripetizione e notificare all'utente il completamento con successo.

Personalizzazione visiva dei pulsanti su Android

A partire da Android 7.0, lo sviluppatore può influenzare l'aspetto di Notification Action attraverso icone e colori. Le icone devono essere monocromatiche (canale alpha), dimensioni 24x24 dp. Su iOS, la personalizzazione dei pulsanti è limitata — vengono utilizzati colori e caratteri di sistema. Material Design raccomanda di raggruppare le azioni per priorità: l'azione più importante per prima, quelle distruttive per ultime.