Background Fetch: o que é, princípio de funcionamento e configuração de atualizações

O que é Background Fetch no iOS?

Background Fetch é uma API do iOS que permite ao aplicativo receber dados atualizados periodicamente em segundo plano. Foi introduzido pela primeira vez no iOS 7 juntamente com o mecanismo Background App Refresh. O principal objetivo é que o conteúdo esteja atualizado quando o usuário abrir o aplicativo, sem necessidade de esperar o carregamento.

Diferença das notificações push

As notificações push são iniciadas pelo servidor — este envia um sinal para o dispositivo e o sistema decide se deve ativar o aplicativo. O Background Fetch é iniciado pelo próprio iOS com base nos padrões de uso do dispositivo. Push é mais adequado para mensagens urgentes, enquanto Fetch é para atualizações programadas de conteúdo (notícias, feed de redes sociais).

Lugar no ecossistema de tarefas em segundo plano

Background Fetch é um dos vários mecanismos de execução em segundo plano no iOS. BGAppRefreshTask (iOS 13+) realiza a mesma tarefa mas com agendamento mais flexível. Background Modes (áudio, localização) são para operações contínuas. Silent Push são atualizações iniciadas pelo servidor. Fetch continua relevante para projetos que suportam iOS 12 e versões anteriores.

• Background Fetch — periódico, iniciado pelo sistema, iOS 7+.
• BGAppRefreshTask — periódico, iniciado pelo sistema, iOS 13+.
• BGProcessingTask — tarefas longas, iOS 13+.
• Silent Push — iniciado pelo servidor, iOS 7+.

Como funciona o Background Fetch: arquitetura e ciclo de vida

iOS utiliza um algoritmo de aprendizagem automática para determinar o momento ideal para ativar o aplicativo. O sistema analisa quando o usuário normalmente abre o aplicativo, quanto tempo o utiliza e com que frequência retorna. Com base nestes dados, o iOS calcula as janelas para Background Fetch.

Processo de execução da tarefa

Quando o sistema decide ativar o aplicativo, chama o método application(_:performFetchWithCompletionHandler:) no AppDelegate. O aplicativo deve carregar uma quantidade mínima de dados novos e chamar o completion handler com um de três estados: .newData (dados carregados), .noData (sem dados novos) ou .failed (erro). O estado afeta a frequência de futuras ativações.

Impacto do completion handler na frequência de chamadas

O estado .newData informa ao sistema que a atualização foi útil — o iOS pode aumentar a frequência de ativações. .noData indica que não há dados — a frequência permanece a mesma ou diminui. .failed sinaliza um problema — o sistema reduz a frequência para economizar bateria. A ênfase deve ser num estado honesto, não em forçar .newData.

Configuração do Background Fetch num projeto Xcode

Para ativar o Background Fetch são necessários dois passos: ativar a capability no Xcode e definir o intervalo mínimo no código. A capability encontra-se em Target — Signing & Capabilities — Background Modes — marcar a caixa Background Fetch. Sem este passo, o sistema não ativará o aplicativo.

Definição do intervalo mínimo

O método UIApplication.shared.setMinimumBackgroundFetchInterval define o tempo mínimo em segundos entre chamadas Fetch. O valor UIApplication.backgroundFetchIntervalMinimum (aproximadamente 15 minutos) indica ao sistema para ativar o aplicativo com a maior frequência possível de forma energeticamente eficiente. Definir o intervalo em application(_:didFinishLaunchingWithOptions:) é uma prática padrão.

func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey : Any]?
)-> Bool {
    UIApplication.shared.setMinimumBackgroundFetchInterval(
        UIApplication.backgroundFetchIntervalMinimum
    )
    return true
}

Info.plist e capability

Ao ativar o Background Fetch no Xcode, este atualiza automaticamente o Info.plist — adiciona a chave UIBackgroundModes com o valor fetch. Este é um passo obrigatório: sem ele, o aplicativo não receberá a chamada performFetchWithCompletionHandler. Pode verificar através de P list Source ou Build Settings.

Exemplos de código Background Fetch em Swift

Vejamos uma implementação completa de Background Fetch para um aplicativo de notícias. A implementação inclui carregamento de dados, cache e chamada do completion handler. O código é executado no AppDelegate — o único local onde o sistema chama fetch.

func application(
    _ application: UIApplication,
    performFetchWithCompletionHandler handler: @escaping (UIBackgroundFetchResult) -> Void
) {
    let url = URL(string: "https://api.example.com/latest")!

    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data = data, error == nil else {
            handler(.failed)
            return
        }

        do {
            let articles = try JSONDecoder().decode([Article].self, from: data)
            cacheArticles(articles)
            handler(articles.isEmpty ? .noData : .newData)
        } catch {
            handler(.failed)
        }
    }.resume()
}

Cache de dados carregados

Após carregar os dados através de Background Fetch, é necessário guardá-los no armazenamento local — CoreData, UserDefaults ou File Manager. Quando o aplicativo abrir, os dados já devem estar disponíveis. Utilize CoreData com um contexto em segundo plano para escrita segura em termos de threads. Após guardar, atualize a interface do usuário na thread principal.

func cacheArticles(_ articles: [Article]) {
    let container = NSPersistentContainer(name: "AppModel")
    container.performBackgroundTask { context in
        articles.forEach { article in
            let entity = ArticleEntity(context: context)
            entity.id = Int64(article.id)
            entity.title = article.title
            entity.body = article.body
        }
        try? context.save()
    }
}

Testar Background Fetch

Para testes, utilize o Simulador — selecione Debug — Simulate Background Fetch no Xcode. Num dispositivo físico, é necessário aguardar que o sistema decida executar fetch. Para acelerar, pode definir o intervalo mínimo para 1 minuto, mas o sistema pode ignorá-lo quando a bateria está baixa.

Limitações e armadilhas

Background Fetch tem várias limitações importantes a considerar ao projetar a arquitetura do aplicativo. A principal é que o sistema controla completamente a frequência das chamadas e o desenvolvedor não pode garanti-la. Mesmo com um intervalo mínimo definido, o sistema pode não chamar fetch durante horas.

Limite de tempo de execução

O sistema aloca tempo limitado para o aplicativo executar a tarefa — normalmente até 30 segundos. Se o aplicativo não chamar o completion handler dentro desse tempo, o sistema encerra forçadamente o processo e reduz a frequência de futuras ativações. Todos os pedidos de rede devem ser compactos — não mais de 1-2 por chamada.

Dependência da bateria

O iOS tem em conta o nível de bateria ao agendar Background Fetch. Quando a carga está abaixo de 20%, a frequência de ativações diminui. Quando o Modo de baixo consumo está ativado, o sistema pode desativar completamente as atualizações em segundo plano para todas as aplicações. O usuário também pode desativar o Background App Refresh para uma aplicação específica nas definições.

Limitações de rede

URLSession iniciada a partir de Background Fetch funciona em modo padrão — sem suporte para sessões em segundo plano. Para descargas grandes, utilize URLSession com configuração em segundo plano. O sistema continuará a descarga mesmo após o fim do fetch, mas o progresso não será rastreado até a próxima ativação.

Migração do Background Fetch para BGTaskScheduler

A partir do iOS 13, a Apple recomenda o BGTaskScheduler como substituto do Background Fetch. O BGTaskScheduler proporciona um agendamento mais flexível, dois tipos de tarefas (refresh e processing) e registo de tarefas com identificadores. A migração inclui vários passos e é recomendada para todos os projetos novos.

Migração passo a passo

O primeiro passo é definir os identificadores de tarefas no Info.plist através da chave BGTaskSchedulerPermittedIdentifiers. O segundo é registar as tarefas no AppDelegate através de BGTaskScheduler.shared.register. O terceiro é substituir a chamada performFetchWithCompletionHandler pelo handler passado ao register. O quarto é chamar submit para agendar a tarefa.

// Antes (Background Fetch)
UIApplication.shared.setMinimumBackgroundFetchInterval(
    UIApplication.backgroundFetchIntervalMinimum
)

// Após migração (BGTaskScheduler)
BGTaskScheduler.shared.register(
    forTaskWithIdentifier: "com.example.refresh",
    using: nil
) { task in
    self.handleAppRefresh(task: task as! BGAppRefreshTask)
}

let request = BGAppRefreshTaskRequest(
    identifier: "com.example.refresh"
)
request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
try? BGTaskScheduler.shared.submit(request)

Vantagens do BGTaskScheduler

O BGTaskScheduler proporciona mais controlo: BGProcessingTask para operações longas (até 10 minutos), condições de execução através de requiresNetworkConnectivity e requiresExternalPower, e um expiration handler para finalização controlada. O sistema também analisa o uso do aplicativo, mas o desenvolvedor pode definir requisitos mais precisos.

Quando manter Background Fetch

Se o aplicativo suportar iOS 12 e versões anteriores, o Background Fetch continua a ser a única opção para atualizações periódicas. O BGTaskScheduler está disponível apenas a partir do iOS 13+. Neste caso, utilize um wrapper: verifique a disponibilidade através de if #available(iOS 13, *) e chame a API correspondente.