PricingLoginStart free
Swift Academy · Lezione

Azioni e categorie delle notifiche

Aggiungi azioni interattive alle notifiche.

Lezione 4 di 413 passaggi

Azioni e categorie delle notifiche è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Notifiche interattive

Le notifiche possono fare più che mostrare testo: possono offrire pulsanti. L'utente può rispondere a un messaggio, accettare un invito o posticipare un promemoria senza aprire l'app. Questa funzionalità si basa su azioni raggruppate in categorie.

import UserNotifications
// Category = a set of actions
// Each delivered notification names its category
// so the system shows the right buttons

Definizione di un'azione

Un UNNotificationAction ha un identificatore, su cui Lei potrà effettuare il confronto in seguito, un titolo localizzato mostrato sul pulsante e opzioni come .destructive o .foreground, che avvia l'app.

import UserNotifications
let accept = UNNotificationAction(
    identifier: "ACCEPT",
    title: String(localized: "Accept"),
    options: [.foreground])
let decline = UNNotificationAction(
    identifier: "DECLINE",
    title: String(localized: "Decline"),
    options: [.destructive])

Raggruppamento in una categoria

Un UNNotificationCategory raggruppa le azioni sotto un identificatore di categoria. L'ordine delle azioni nell'array corrisponde all'ordine dei pulsanti. Registri le categorie una volta sola all'avvio con il centro notifiche.

import UserNotifications
let inviteCategory = UNNotificationCategory(
    identifier: "INVITE",
    actions: [accept, decline],
    intentIdentifiers: [],
    options: [])
UNUserNotificationCenter.current()
    .setNotificationCategories([inviteCategory])

Associare una categoria a una notifica

Per visualizzare i pulsanti, il contenuto della notifica deve impostare categoryIdentifier su una categoria registrata. Per le push remote, il server invia "category": "INVITE" all'interno del dizionario aps.

import UserNotifications
let content = UNMutableNotificationContent()
content.title = String(localized: "New invite")
content.body = String(localized: "Ada invited you")
content.categoryIdentifier = "INVITE"

Gestire l'azione scelta

Quando l'utente tocca un pulsante, viene eseguito il metodo didReceive response del delegato, con response.actionIdentifier impostato sull'ID dell'azione. Utilizzi uno switch su questo valore per eseguire l'operazione corretta.

import UserNotifications
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse
) async {
    switch response.actionIdentifier {
    case "ACCEPT":  print("accepted")
    case "DECLINE": print("declined")
    default:        break
    }
}

Identificatori dell'azione predefinita e di chiusura

Esistono sempre due identificatori di sistema: UNNotificationDefaultActionIdentifier indica che l'utente ha toccato il corpo per aprire l'app, mentre UNNotificationDismissActionIdentifier indica che l'ha chiusa. Gestisca questi identificatori insieme alle azioni personalizzate.

import UserNotifications
func route(_ id: String) {
    switch id {
    case UNNotificationDefaultActionIdentifier:
        print("opened the app")
    case UNNotificationDismissActionIdentifier:
        print("dismissed")
    default:
        print("custom action", id)
    }
}

Azioni con immissione di testo

Un UNTextInputNotificationAction mostra un campo di testo incorporato, perfetto per le risposte rapide. Aggiunge un titolo per il pulsante e un segnaposto per la casella di immissione.

import UserNotifications
let reply = UNTextInputNotificationAction(
    identifier: "REPLY",
    title: String(localized: "Reply"),
    options: [],
    textInputButtonTitle: String(localized: "Send"),
    textInputPlaceholder: String(localized: "Message"))

Lettura del testo immesso

Per un'azione di testo, la risposta è un oggetto UNTextInputNotificationResponse. Esegua il cast a questo tipo per leggere userText, la stringa digitata dall'utente.

import UserNotifications
func handle(_ response: UNNotificationResponse) {
    if let textResponse = response
        as? UNTextInputNotificationResponse {
        let message = textResponse.userText
        print("reply:", message)
    }
}

Opzioni della categoria

Le opzioni della categoria permettono di definire più precisamente il comportamento: .customDismissAction invia l'evento di chiusura al delegato, .hiddenPreviewsShowTitle mostra il titolo anche quando le anteprime sono nascoste nella schermata di blocco e .allowInCarPlay consente la visualizzazione in CarPlay.

import UserNotifications
let category = UNNotificationCategory(
    identifier: "MESSAGE",
    actions: [reply],
    intentIdentifiers: [],
    options: [.customDismissAction,
              .hiddenPreviewsShowTitle])
_ = category

Azioni in background e in primo piano

Senza l'opzione .foreground, un'azione esegue il gestore in background senza portare l'app in primo piano, una soluzione ideale per posticipare un promemoria o mettere un like. Con .foreground, l'app viene avviata per consentirLe di mostrare un'interfaccia. Scelga in base alla necessità dell'utente di visualizzare o meno qualcosa.

import UserNotifications
let snooze = UNNotificationAction(
    identifier: "SNOOZE",
    title: String(localized: "Snooze"),
    options: []) // background, no app launch
let open = UNNotificationAction(
    identifier: "OPEN",
    title: String(localized: "Open"),
    options: [.foreground]) // launches app
_ = (snooze, open)

Un flusso completo di risposta

Combini un'azione di testo, una categoria e un gestore che distingua la risposta digitata da una semplice apertura. Questo schema permette di gestire le risposte ai messaggi in linea.

import UserNotifications
func handle(_ response: UNNotificationResponse) async {
    switch response.actionIdentifier {
    case "REPLY":
        let text = (response as?
            UNTextInputNotificationResponse)?.userText ?? ""
        print("send reply:", text)
    case UNNotificationDefaultActionIdentifier:
        print("open conversation")
    default:
        break
    }
}

Verifica rapida

Ricordi come il sistema sa quali pulsanti mostrare.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato a usare le notifiche interattive:

  • Crei oggetti UNNotificationAction, inclusi gli oggetti UNTextInputNotificationAction, e li raggruppi in una UNNotificationCategory.
  • Registri le categorie all'avvio; imposti categoryIdentifier nel contenuto, oppure category nella push, per mostrare i pulsanti.
  • Gestisca response.actionIdentifier, inclusi gli identificatori predefinito e di chiusura, e legga userText per le risposte.
  • Ometta .foreground per le azioni in background, come il posticipo.
Gratis per iniziare

Impara Swift con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
122
Lezioni
409
Inizia a imparare gratisVisualizza il corso completo

Domande Frequenti

La lezione «Azioni e categorie delle notifiche» è gratuita?

Sì — il testo completo di «Azioni e categorie delle notifiche» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Azioni e categorie delle notifiche»?

Aggiungi azioni interattive alle notifiche. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Azioni e categorie delle notifiche»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Registrazione alle notifiche push
  2. Gestione dei payload delle notifiche
  3. Attività e aggiornamento in background
  4. Azioni e categorie delle notifiche
← Torna a Swift Academy