22.11.2024

Aula 108: Lidando com Notificações e Ciclo de Vida do App

Nesta aula, vamos explorar como lidar com notificações em sua aplicação iOS, além de entender os eventos do ciclo de vida do app. Este conhecimento é fundamental para construir aplicações responsivas e amigáveis ao usuário.

Compreendendo o Ciclo de Vida do App

O ciclo de vida de uma aplicação iOS é gerenciado pelo UIApplicationDelegate. Este delegate é responsável por monitorar o estado do app enquanto ele passa por diferentes estados: inativo, ativo, em segundo plano e finalizado. Vamos observar os estados básicos:

• Não executando: O app não está sendo executado.
• Inativo: O app está em execução, mas não está recebendo eventos. Isso pode ocorrer durante uma interrupção temporária (como uma chamada telefônica).
• Ativo: O app está em execução em primeiro plano e recebendo eventos.
• Em segundo plano: O app está em segundo plano e executando código (tempo limitado).
• Suspenso: O app está em segundo plano, mas não está executando código.

Implementando Métodos do Ciclo de Vida do App

Para responder a mudanças no ciclo de vida, você precisa implementar métodos no seu AppDelegate.

Aqui está como você pode gerenciar os eventos do ciclo de vida da aplicação:

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Este método é chamado quando o app concluiu seu lançamento.
        print("Aplicativo foi iniciado.")
        return true
    }

    func applicationDidBecomeActive(_ application: UIApplication) {
        // Reinicie quaisquer tarefas que estavam pausadas (ou ainda não iniciadas) enquanto o aplicativo estava inativo.
        print("Aplicativo se tornou ativo.")
    }

    func applicationWillResignActive(_ application: UIApplication) {
        // Este método é chamado quando o app está prestes a mudar de estado ativo para inativo.
        print("Aplicativo irá ficar inativo.")
    }

    func applicationDidEnterBackground(_ application: UIApplication) {
        // Libere recursos compartilhados, salve dados do usuário, invalide timers, etc.
        print("Aplicativo entrou em segundo plano.")
    }

    func applicationWillEnterForeground(_ application: UIApplication) {
        // Chamado como parte da transição do segundo plano para o estado inativo.
        print("Aplicativo irá voltar para o primeiro plano.")
    }

    func applicationWillTerminate(_ application: UIApplication) {
        // Chamado quando o aplicativo está prestes a ser finalizado.
        print("Aplicativo irá ser finalizado.")
    }
}

Lidando com Notificações

Notificações são uma parte fundamental da experiência do usuário em aplicativos. No iOS, você pode lidar com notificações locais e remotas. Aqui, vamos nos concentrar nas notificações locais.

Solicitando Permissão

Antes de enviar notificações, você precisa solicitar permissão ao usuário:

import UserNotifications

func requestNotificationPermission() {
    let center = UNUserNotificationCenter.current()
    center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
        if let error = error {
            // Lide com o erro aqui.
            print("Erro ao solicitar permissão: \(error)")
        }
    }
}

Chame esta função no seu método didFinishLaunchingWithOptions ou quando você quiser pedir permissão.

Agendando uma Notificação

Uma vez que você tenha permissão, pode agendar notificações:

func scheduleNotification() {
    let content = UNMutableNotificationContent()
    content.title = "Olá!"
    content.body = "Esta é uma notificação local."
    content.sound = UNNotificationSound.default

    // Configure o gatilho para um atraso de 5 segundos.
    let trigger = UNTimeIntervalNotificationTrigger(timeInterval: 5, repeats: false)

    // Crie a solicitação.
    let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: trigger)

    // Agende a solicitação com o sistema.
    let center = UNUserNotificationCenter.current()
    center.add(request) { error in
        if let error = error {
            print("Erro ao agendar notificação: \(error)")
        }
    }
}

Você pode chamar esta função após solicitar permissão.

Respondendo a Notificações

Para lidar com notificações quando seu aplicativo está em primeiro plano, implemente o seguinte método no seu AppDelegate:

func userNotificationCenter(_ center: UNUserNotificationCenter, 
                            willPresent notification: UNNotification, 
                            withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    // Exiba o alerta da notificação em primeiro plano
    completionHandler([.alert, .sound])
}

Não se esqueça de definir o delegate:

center.delegate = self

Configuração Final

Por fim, você precisa garantir que seu AppDelegate conforme-se ao protocolo UNUserNotificationCenterDelegate:

class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {
    // Seu código...
}

Conclusão

Nesta aula, aprendemos como lidar com eventos do ciclo de vida do app e gerenciar notificações locais. Compreender esses conceitos é essencial para criar uma experiência de aplicação envolvente e amigável ao usuário. À medida que você constrói aplicações mais complexas, você achará essas técnicas inestimáveis na gestão das interações do usuário e do comportamento do app.

Video

Navigation