Swift Academy · Aula

Tratamento de Cargas de Notificação

Responda a notificações em primeiro e segundo plano.

Tratamento de Cargas de Notificação é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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.

A estrutura da carga útil

Uma notificação remota é um dicionário JSON que seu servidor envia ao APNs. A chave reservada aps contém o conteúdo visível para o usuário — alerta, som e contador — enquanto as chaves no mesmo nível carregam seus dados personalizados, como um identificador de item a ser aberto.

// Example payload JSON:
// {
//   "aps": { "alert": { "title": "Hi", "body": "..." },
//            "sound": "default", "badge": 1 },
//   "itemId": "42"
// }

O dicionário aps

Dentro de aps, alert pode ser um texto ou um objeto com título, corpo e subtítulo. sound, badge e sinalizadores como content-available e mutable-content também ficam aqui. Tudo que estiver fora de aps é definido por você.

// aps keys:
//   alert: { title, subtitle, body }
//   sound: "default" or critical sound object
//   badge: Int
//   content-available: 1  (silent / background)
//   mutable-content: 1    (allow modification)

Entrega em primeiro plano

Por padrão, uma notificação recebida enquanto o aplicativo está em primeiro plano não é exibida. Para exibi-la mesmo assim, implemente o willPresent do delegado e retorne as opções de apresentação desejadas, como uma faixa e um som.

import UserNotifications
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    willPresent notification: UNNotification
) async -> UNNotificationPresentationOptions {
    return [.banner, .sound, .badge]
}

Respondendo a um toque

Quando o usuário toca em uma notificação, esteja o aplicativo em segundo plano ou encerrado, o didReceive response do delegado é executado. É nesse ponto que você lê a carga útil e navega até a tela correta.

import UserNotifications
func userNotificationCenter(
    _ center: UNUserNotificationCenter,
    didReceive response: UNNotificationResponse
) async {
    let info = response.notification.request
        .content.userInfo
    if let id = info["itemId"] as? String {
        print("open item", id)
    }
}

Lendo userInfo

A carga útil completa, incluindo suas chaves personalizadas, é exposta como content.userInfo — um dicionário [AnyHashable: Any]. Converta cada valor com cuidado; nunca desembrulhe valores à força, pois uma carga malformada não deve fazer o aplicativo falhar.

import UserNotifications
func route(_ userInfo: [AnyHashable: Any]) {
    guard let screen = userInfo["screen"] as? String
    else { return }
    switch screen {
    case "profile": print("go to profile")
    case "cart":    print("go to cart")
    default:        break
    }
}

Notificações silenciosas (em segundo plano)

Definir content-available: 1 e omitir um alerta cria uma notificação remota silenciosa que desperta o aplicativo em segundo plano para buscar dados, sem interface. Essas notificações são limitadas pelo sistema e exigem o modo de notificações remotas em segundo plano.

// Silent payload — no alert, just a wake-up:
// { "aps": { "content-available": 1 }, "sync": true }
let silent = "content-available wakes app quietly"
_ = silent

Manipulador de busca em segundo plano

Uma notificação silenciosa chega ao método assíncrono didReceiveRemoteNotification do delegado do aplicativo. Você realiza a busca e retorna um UIBackgroundFetchResult para que o sistema saiba se chegaram dados novos e possa reservar recursos para futuras ativações.

import UIKit
func application(
    _ app: UIApplication,
    didReceiveRemoteNotification userInfo: [AnyHashable: Any]
) async -> UIBackgroundFetchResult {
    // fetch fresh data here
    return .newData
}

Conteúdo mutável e extensões de serviço

Com mutable-content: 1, uma extensão de serviço de notificações pode interceptar a notificação antes da exibição — para descriptografar o corpo, baixar um anexo de imagem ou reescrever o título. A extensão tem pouco tempo para concluir o trabalho.

// Service extension entry point (UNNotificationServiceExtension):
// override didReceive(_:withContentHandler:)
//   modify bestAttemptContent, then call contentHandler
let mutable = "mutable-content enables interception"
_ = mutable

Localizando o alerta

Para localizar textos no servidor, envie title-loc-key e loc-key, referenciando chaves nos textos localizáveis do aplicativo, além de loc-args para as substituições. O dispositivo os renderiza no idioma do usuário sem que você precise enviar um texto previamente traduzido.

// Localized alert payload:
// "alert": {
//   "loc-key": "NEW_MESSAGE",
//   "loc-args": ["Ada"]
// }
let localized = "loc-key resolves on device"
_ = localized

Atualizando o contador

O valor de badge define o número exibido no ícone do aplicativo. Enviar badge: 0 o remove. Você também pode defini-lo no código por meio de setBadgeCount depois que o usuário ler o conteúdo, mantendo o contador sincronizado com o estado de itens não lidos.

import UserNotifications
func clearBadge() async {
    try? await UNUserNotificationCenter.current()
        .setBadgeCount(0)
}

Um manipulador robusto

Combine as partes: exiba as notificações em primeiro plano, direcione o usuário ao tocar e valide cada conversão de tipo. O manipulador nunca falha com cargas inesperadas e sempre extrai tudo que consegue.

import UserNotifications
func handleTap(_ response: UNNotificationResponse) {
    let info = response.notification.request
        .content.userInfo
    guard let id = info["itemId"] as? String else {
        print("no item id; open home")
        return
    }
    print("navigate to item", id)
}

Verificação rápida

Relembre como reagir a um toque em uma notificação.

Resumo

Você aprendeu a lidar com cargas úteis:

O dicionário aps contém o conteúdo visível para o usuário; as chaves no mesmo nível contêm seus dados, lidos por meio de userInfo.
Substitua willPresent para exibir notificações em primeiro plano e didReceive response para lidar com toques.
content-available: 1 inicia buscas silenciosas em segundo plano que retornam um UIBackgroundFetchResult.
mutable-content ativa uma extensão de serviço; loc-key localiza o texto no dispositivo.

Perguntas Frequentes

A aula “Tratamento de Cargas de Notificação” é grátis?

Sim — o texto completo de “Tratamento de Cargas 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 “Tratamento de Cargas de Notificação”?

Responda a notificações em primeiro e segundo plano. 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 2 de 4.

Quanto tempo leva a aula “Tratamento de Cargas 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