Swift Academy · Aula

Ações e Categorias de Notificação

Adicione ações interativas às notificações.

Ações e Categorias de Notificação é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Notificações interativas

As notificações podem fazer mais do que exibir texto — elas podem oferecer botões. O usuário pode responder a uma mensagem, aceitar um convite ou adiar um lembrete sem abrir o aplicativo. Isso é construído a partir de ações agrupadas em categorias.

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

Definindo uma ação

Uma UNNotificationAction tem um identificador, que você usará para compará-lo depois, um título localizado exibido no botão e opções como .destructive ou .foreground, que abre o aplicativo.

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

Agrupando em uma categoria

Uma UNNotificationCategory reúne ações sob um identificador de categoria. A ordem das ações na lista é a ordem dos botões. Você registra as categorias uma vez na inicialização, usando o centro de notificações.

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

Associando uma notificação à sua categoria

Para que os botões apareçam, o conteúdo da notificação deve definir categoryIdentifier como uma categoria registrada. Para notificações remotas, o servidor envia "category": "INVITE" dentro do dicionário aps.

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

Lidando com a ação escolhida

Quando o usuário toca em um botão, o didReceive response do delegado é acionado com response.actionIdentifier definido como o identificador da sua ação. Faça uma seleção com base nele para executar o trabalho correto.

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

Identificadores padrão e de dispensa

Dois identificadores do sistema sempre existem: UNNotificationDefaultActionIdentifier indica que o usuário tocou no corpo para abrir o aplicativo, e UNNotificationDismissActionIdentifier indica que ele dispensou a notificação. Lide com eles junto com suas ações personalizadas.

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

Ações de entrada de texto

Uma UNTextInputNotificationAction exibe um campo de texto embutido — perfeito para respostas rápidas. Ela adiciona um título de botão e um texto de espaço reservado para o campo de entrada.

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

Lendo o texto digitado

Para uma ação de texto, a resposta é uma UNTextInputNotificationResponse. Converta-a para esse tipo para ler userText, o texto que o usuário digitou.

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

Opções de categoria

As opções de categoria refinam o comportamento: .customDismissAction entrega o evento de dispensa ao delegado, .hiddenPreviewsShowTitle revela o título mesmo quando as prévias estão ocultas na tela bloqueada e .allowInCarPlay permite a exibição no CarPlay.

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

Ações em segundo plano e em primeiro plano

Sem a opção .foreground, uma ação executa seu manipulador em segundo plano sem trazer o aplicativo para a frente — ideal para adiar algo ou indicar que gostou. Com .foreground, o aplicativo é aberto para que você possa exibir uma interface. Escolha com base na necessidade de o usuário ver algo.

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)

Um fluxo completo de resposta

Combine uma ação de texto, uma categoria e um manipulador que diferencie a resposta digitada de uma simples abertura. Esse padrão permite respostas a mensagens em linha.

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ção rápida

Relembre como o sistema sabe quais botões exibir.

Resumo

Você aprendeu sobre notificações interativas:

Crie UNNotificationActions, incluindo UNTextInputNotificationAction, e agrupe-as em uma UNNotificationCategory.
Registre as categorias na inicialização; defina categoryIdentifier no conteúdo, ou category na notificação, para exibir os botões.
Lide com response.actionIdentifier, incluindo os identificadores padrão e de dispensa, e leia userText para obter as respostas.
Omita .foreground para ações em segundo plano, como adiar um lembrete.

Perguntas Frequentes

A aula “Ações e Categorias de Notificação” é grátis?

Sim — o texto completo de “Ações e Categorias de Notificação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Ações e Categorias de Notificação”?

Adicione ações interativas às notificações. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Ações e Categorias de Notificação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Swift Academy