Swift Academy · Aula

Tarefas em Segundo Plano e Atualização

Agende trabalho em segundo plano com BGTaskScheduler.

Tarefas em Segundo Plano e Atualização é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 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.

Por que existem as tarefas em segundo plano

O iOS suspende os aplicativos agressivamente para economizar bateria. Para realizar um trabalho significativo enquanto estão em segundo plano — atualizar um fluxo, processar uma transferência — você o agenda por meio de BGTaskScheduler. O sistema decide quando executá-lo, equilibrando suas necessidades com o consumo de energia e os padrões de uso.

import BackgroundTasks
// You request work; the system schedules it later
// at an opportune moment (charging, on Wi-Fi, etc.)

Dois tipos de tarefa

Há dois tipos: BGAppRefreshTask para atualizações curtas e frequentes (segundos) e BGProcessingTask para trabalhos mais longos e pesados (minutos), como manutenção de banco de dados, podendo exigir energia ou rede.

import BackgroundTasks
// BGAppRefreshTask  -> quick content refresh
// BGProcessingTask  -> long maintenance, can require
//                      external power / network

Declarando identificadores

Cada tarefa precisa de um identificador exclusivo, que você lista em Info.plist sob BGTaskSchedulerPermittedIdentifiers. Sem essa declaração, o registro falha. Use textos no formato de DNS reverso.

// Info.plist:
// BGTaskSchedulerPermittedIdentifiers = [
//   "com.example.app.refresh",
//   "com.example.app.cleanup"
// ]
let ids = "declare every identifier in Info.plist"
_ = ids

Registrando um manipulador

Na inicialização, registre um manipulador para cada identificador com BGTaskScheduler.shared.register. Isso deve acontecer antes de o aplicativo terminar de iniciar. O manipulador é executado sempre que o sistema decidir executar a tarefa posteriormente.

import BackgroundTasks
func registerTasks() {
    BGTaskScheduler.shared.register(
        forTaskWithIdentifier: "com.example.app.refresh",
        using: nil) { task in
        handleRefresh(task as! BGAppRefreshTask)
    }
}

Enviando uma solicitação

O registro apenas conecta o manipulador. Para realmente solicitar uma execução, crie um BGAppRefreshTaskRequest, defina a data de início mais cedo e use submit. O sistema trata essa data como uma sugestão, não como uma garantia.

import BackgroundTasks
func scheduleRefresh() {
    let request = BGAppRefreshTaskRequest(
        identifier: "com.example.app.refresh")
    request.earliestBeginDate = Date(
        timeIntervalSinceNow: 15 * 60)
    try? BGTaskScheduler.shared.submit(request)
}

Sempre reagende

Uma solicitação enviada é executada no máximo uma vez. Para continuar atualizando, seu manipulador deve enviar a próxima solicitação antes de terminar. Reagende primeiro e depois faça o trabalho, para que uma falha no meio da execução não interrompa o ciclo.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh() // queue the next run first
    // ... then perform this run's work
}

Sinalizando a conclusão

Você deve chamar task.setTaskCompleted(success:) ao terminar. Esquecer essa chamada desperdiça seu orçamento de execução em segundo plano e pode reduzir a prioridade de tarefas futuras. Informe se o trabalho foi bem-sucedido para que o sistema possa adaptar o agendamento.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh()
    Task {
        let ok = await fetchLatest()
        task.setTaskCompleted(success: ok)
    }
}
func fetchLatest() async -> Bool { true }

Respeitando o manipulador de expiração

O sistema pode recuperar o tempo antes do previsto. Defina task.expirationHandler para cancelar o trabalho em andamento e fazer a limpeza, saindo corretamente se a execução for interrompida. Trate-o como um alarme de prazo.

import BackgroundTasks
func handle(_ task: BGAppRefreshTask) {
    let work = Task { await fetchLatest() }
    task.expirationHandler = {
        work.cancel() // stop before the OS suspends us
    }
}
func fetchLatest() async -> Bool { true }

Processando tarefas com requisitos

Para trabalhos pesados, BGProcessingTaskRequest permite definir requiresNetworkConnectivity e requiresExternalPower. O sistema aguarda essas condições, para que tarefas longas sejam executadas enquanto o dispositivo carrega durante a noite conectado ao Wi-Fi.

import BackgroundTasks
func scheduleCleanup() {
    let req = BGProcessingTaskRequest(
        identifier: "com.example.app.cleanup")
    req.requiresExternalPower = true
    req.requiresNetworkConnectivity = false
    try? BGTaskScheduler.shared.submit(req)
}

Testando no depurador

Você não precisa esperar horas para que o sistema faça o agendamento. Pause no depurador e execute um comando do LLDB para forçar a inicialização imediata de uma tarefa registrada, verificando o manipulador de ponta a ponta.

// In LLDB while paused:
// e -l objc -- (void)[[BGTaskScheduler sharedScheduler]
//   _simulateLaunchForTaskWithIdentifier:
//   @"com.example.app.refresh"]
let test = "force-launch task via LLDB"
_ = test

Um ciclo completo de atualização

Reunindo tudo: registre na inicialização, envie a solicitação ao entrar em segundo plano e, no manipulador, reagende, proteja com um manipulador de expiração, realize o trabalho assíncrono e informe a conclusão.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh()
    let work = Task { await fetchLatest() }
    task.expirationHandler = { work.cancel() }
    Task {
        let ok = await work.value
        task.setTaskCompleted(success: ok)
    }
}
func fetchLatest() async -> Bool { true }

Verificação rápida

Relembre o ciclo de vida de uma tarefa de atualização recorrente.

Resumo

Você aprendeu sobre o agendamento em segundo plano:

BGAppRefreshTask para atualizações curtas e BGProcessingTask para manutenção longa com requisitos de energia ou rede.
Declare os identificadores no Info.plist, registre os manipuladores na inicialização com register e envie as solicitações com submit, usando um earliestBeginDate.
Agende a próxima execução dentro do manipulador, defina um expirationHandler e sempre chame setTaskCompleted.
Force a inicialização das tarefas por meio do LLDB para testar.

Perguntas Frequentes

A aula “Tarefas em Segundo Plano e Atualização” é grátis?

Sim — o texto completo de “Tarefas em Segundo Plano e Atualizaçã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 “Tarefas em Segundo Plano e Atualização”?

Agende trabalho em segundo plano com BGTaskScheduler. 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 3 de 4.

Quanto tempo leva a aula “Tarefas em Segundo Plano e Atualizaçã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