Swift Academy · Aula

Registro para Notificações Push

Solicite permissão e obtenha um token do dispositivo.

Aula 1 de 413 etapas

Registro para Notificações Push é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 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.

Como funciona o envio de notificações de ponta a ponta

Uma notificação enviada viaja do seu servidor, passa pelo serviço Apple Push Notification (APNs) e chega a um dispositivo específico. O dispositivo comprova sua identidade usando um token do dispositivo emitido pelo APNs. Antes de tudo isso, o usuário precisa conceder permissão e o aplicativo precisa se registrar.

// Flow: App registers -> APNs returns device token ->
// you send token to your server -> server pushes via APNs

A Central de Notificações

UNUserNotificationCenter é o único objeto usado para tudo relacionado a notificações locais e remotas: solicitar autorização, definir o delegado, agendar notificações locais e ler os ajustes. Obtenha a instância compartilhada.

import UserNotifications
let center = UNUserNotificationCenter.current()
// All notification configuration goes through center

Solicitando autorização

Você precisa perguntar ao usuário antes de mostrar notificações. requestAuthorization(options:) exibe a solicitação do sistema e informa se o usuário concordou. Solicite apenas as opções necessárias: .alert, .sound e .badge.

import UserNotifications
func requestAuth() async throws -> Bool {
    let center = UNUserNotificationCenter.current()
    return try await center.requestAuthorization(
        options: [.alert, .sound, .badge])
}

Registrando-se no APNs

A autorização é separada do registro. Depois de obter a permissão, ou ao mesmo tempo que a obtém, chame registerForRemoteNotifications() no ator principal. Isso solicita um token do dispositivo ao APNs. A chamada precisa ser executada na thread principal.

import UIKit
@MainActor
func registerForPush() {
    UIApplication.shared.registerForRemoteNotifications()
}

Recebendo o token do dispositivo

Quando há sucesso, o método do delegado do aplicativo didRegisterForRemoteNotificationsWithDeviceToken é acionado com um token Data. Você o converte em um texto hexadecimal e o envia ao seu servidor, que o usa para direcionar notificações a este dispositivo.

import UIKit
func application(
    _ app: UIApplication,
    didRegisterForRemoteNotificationsWithDeviceToken
    deviceToken: Data) {
    let token = deviceToken.map {
        String(format: "%02x", $0) }.joined()
    print("APNs token:", token)
    // send token to your backend
}

Tratando falhas no registro

O registro pode falhar — por falta de rede, ausência da autorização do APNs ou execução em um ambiente sem suporte. Implemente didFailToRegisterForRemoteNotificationsWithError para registrar o erro e se recuperar de forma adequada, em vez de causar uma falha.

import UIKit
func application(
    _ app: UIApplication,
    didFailToRegisterForRemoteNotificationsWithError
    error: Error) {
    print("Push registration failed:", error)
}

Os tokens podem mudar

Um token do dispositivo não é permanente. Ele muda quando o usuário restaura um backup, reinstala o aplicativo ou muda para um novo dispositivo. Registre-se sempre a cada inicialização e envie o token mais recente, substituindo o antigo no servidor.

// Best practice: register on each launch,
// always upload the freshly received token,
// never cache a token as permanent.
let rule = "re-register every launch"
_ = rule

Verificando os ajustes atuais

O usuário pode revogar a permissão mais tarde nos Ajustes. Antes de depender das notificações, consulte getNotificationSettings para ler o status de autorização atual e quais recursos estão permitidos.

import UserNotifications
func currentStatus() async -> UNAuthorizationStatus {
    let settings = await UNUserNotificationCenter
        .current().notificationSettings()
    return settings.authorizationStatus
}

Autorização provisória

A opção .provisional permite que as notificações cheguem silenciosamente à Central de Notificações, sem uma solicitação inicial. Isso é ótimo para permitir que os usuários experimentem as notificações antes de decidir, com a opção de mantê-las ou desativá-las.

import UserNotifications
func requestQuiet() async throws -> Bool {
    try await UNUserNotificationCenter.current()
        .requestAuthorization(
            options: [.alert, .sound, .provisional])
}

O recurso necessário

Nada disso funciona sem ativar o recurso Notificações Push no destino do Xcode, o que adiciona a autorização aps-environment. Para a entrega em segundo plano, você também deve ativar o recurso Modos de Segundo Plano com notificações remotas.

// Xcode target > Signing & Capabilities:
//   + Push Notifications
//   + Background Modes > Remote notifications
let caps = "entitlements required"
_ = caps

Reunindo o registro

Um fluxo de inicialização organizado é: solicitar autorização e, se ela for concedida, registrar-se para receber notificações remotas no ator principal. O token chega então no retorno de chamada do delegado para ser enviado.

import UIKit
import UserNotifications
func setupPush() async {
    let center = UNUserNotificationCenter.current()
    let granted = (try? await center.requestAuthorization(
        options: [.alert, .sound, .badge])) ?? false
    if granted {
        await MainActor.run {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
}

Verificação rápida

Relembre a relação entre autorização e registro.

Responda na aula interativa

Recapitulação

Você aprendeu como se registrar para receber notificações remotas:

Use UNUserNotificationCenter para solicitar autorização para .alert/.sound/.badge.
Autorização e registro são etapas separadas; chame registerForRemoteNotifications() no ator principal.
Converta o token de Data para hexadecimal e envie-o ao servidor; registre-se novamente a cada inicialização, pois os tokens mudam.
Ative o recurso Notificações Push e considere a autorização .provisional.

Grátis para começar

Aprenda Swift com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 122
Aulas: 409

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Registro para Notificações Push” é grátis?

Sim — o texto completo de “Registro para Notificações Push” é 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 “Registro para Notificações Push”?

Solicite permissão e obtenha um token do dispositivo. 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 1 de 4.

Quanto tempo leva a aula “Registro para Notificações Push”?

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