Conclua tarefas em segundo plano

Conclua tarefas em segundo plano

Descubra os avanços na execução em segundo plano e entenda como o sistema programa o tempo de execução. Abordaremos como aproveitar ao máximo o tempo de execução em segundo plano para permitir que seu app ofereça recursos em segundo plano enquanto mantém uma ótima experiência em primeiro plano. Também vamos explicar como as APIs oferecem suporte ao tempo de execução em segundo plano para seu app e como cada API é adequada para diferentes casos de uso, incluindo as novas APIs do iOS e do iPadOS 26, que permitem que seu app conclua tarefas durante a transição do primeiro para o segundo plano.

Capítulos
- 0:00 - Apresentação
- 1:22 - Introdução
- 2:09 - Comportamentos e restrições
- 7:29 - APIs de tarefas em segundo plano
- 11:23 - Tarefas de processamento contínuo
Recursos
Olá! Meu nome é Ryan. Sou software engineer na Apple. Hoje quero conversar sobre como seu app pode usar o tempo de execução em segundo plano.
A App Store conta com milhões de apps, e cada um deles tem algo único. O app chama mais atenção quando está em destaque. Com todos os pixels à sua disposição, você pode promover experiências memoráveis. Isto é o que as pessoas esperam: apps rápidos, úteis e bem-elaborados de desenvolvedores como você. Mas o que acontece quando o app passa para o segundo plano? Nesta sessão, vou explorar o tempo de execução em segundo plano, criando um kit de ferramentas adaptado ao seu app e que seja eficiente e de bom desempenho. Não se trata apenas de estar disponível. Ele precisa ser útil, ter recursos de busca antecipada, sincronização e upload, estar pronto para uso quando for iniciado. Se for bem usado, o tempo de execução em segundo plano deixa seu app rápido, constante e até um pouco mágico. Vou começar com uma rápida visão geral do que significam primeiro plano e segundo plano vou compartilhar alguns princípios sobre como o sistema decide quando e com que frequência os apps serão executados em segundo plano. Em seguida, vou abordar as muitas maneiras existentes de fazer isso, incluindo uma nova API para tarefas contínuas que foram iniciadas em primeiro plano.
Todos os apps em primeiro plano seguem o mesmo ritmo.
O app em si e tudo o que ele precisa (frameworks, ativos e muito mais) são carregados na memória. Nesse estado, a interface do app é o foco no dispositivo, e o app fica em primeiro plano.
Quando alguém sai do app, mas o processo continua ativo, ele entra em segundo plano. Por padrão, os apps em segundo plano são suspensos. Eles não têm tempo de CPU. Isso protege a duração da bateria, preserva a privacidade e libera recursos para apps em primeiro plano.
Em alguns casos, o app pode solicitar tempo em segundo plano para concluir o trabalho em andamento antes da suspensão. O app é retomado pelo sistema quando a pessoa retorna a ele no seletor de apps e passa a estar em primeiro plano. Antes de usar o tempo de execução em segundo plano, será útil entender como o sistema prioriza e gerencia recursos e o que você pode fazer no app para criar a melhor experiência.
Os principais objetivos do sistema são simples: proteger a duração da bateria e otimizar o desempenho, preservando uma experiência fluida e responsiva. Isso significa que a execução em segundo plano não é garantida. Em vez disso, é oportunista, muitas vezes arbitrária e rigidamente administrada. As cargas de trabalho bem-sucedidas entendem esse contexto e são projetadas para trabalhar com o sistema, não contra ele. A restrição mais fundamental é a energia.
Cada operação, ciclos de CPU, renderização de GPU, solicitações de rede e até mesmo o uso do Neural Engine têm um custo de bateria associado. A duração da bateria é um recurso finito. Para preservá-la, o sistema aglutina o trabalho quando os dispositivos despertam, reduzindo a atividade desnecessária em segundo plano ao longo do dia. Como o tempo de execução em segundo plano é limitado, pense naquilo que o app deve fazer em segundo plano, como tarefas dedicadas e personalizadas. Cada tarefa faz algo forma eficiente, considerando as prioridades e restrições do sistema. Esse trabalho em segundo plano se reflete nos "Ajustes da Bateria", onde é possível ver quais apps afetam significativamente a duração da bateria. O iOS 26 inclui informações incríveis sobre o desempenho da bateria do dispositivo, com detalhes específicos do app.
Sua melhor jogada aqui é ser eficiente. Se uma tarefa não precisa ser executada imediatamente, considere adiá-la até que o dispositivo esteja carregando. Se ela precisar funcionar, mantenha-a leve e objetiva. O sistema também é responsável por gerenciar outros recursos compartilhados, como memória, tempo de CPU e largura de banda da rede. Quando alguém estiver usando o dispositivo, o app em primeiro plano será priorizado. Se um app em segundo plano consome muita memória ou CPU, ele não é apenas ineficiente. Ele também concorre com a experiência de primeiro plano. Nesse momento, o sistema pode intervir. Limitar, suspender ou até mesmo encerrar processos que exigem muito. A lição é simples. Mantenha um nível mínimo de trabalho em segundo plano. Evite o excesso de trabalho e prefira o processamento em lote para minimizar o espaço ocupado pela memória. Mesmo quando as cargas de trabalho têm bom desempenho, não há garantia de que elas serão permitidas por muito tempo. A fila de trabalho em segundo plano nunca está vazia, portanto, o sistema pode optar por priorizar outras cargas de trabalho. Dito isso, estamos todos trabalhando como uma equipe aqui, com o sistema fazendo o trabalho de maximizar a experiência em primeiro plano. Suas cargas de trabalho devem ser resilientes. Poupe o progresso incremental com antecedência e frequência. Responda aos sinais de expiração rapidamente e confie que o sistema retornará em breve à sua carga de trabalho. Ele valoriza processos cooperativos, utilizando esses comportamentos para influenciar a programação futura. Mas, no fim das contas, a decisão é de quem usa o dispositivo. As pessoas influenciam a programação quando alteram ajustes como Pouca Energia, Atualização em Segundo Plano e Modo de Economia de Dados. O sistema fornece transparência, capacitando as pessoas a tomar essas decisões por conta própria. Por exemplo, se o app esgotar muita bateria em segundo plano, elas podem tomar decisões não necessariamente ao seu favor.
Portanto, o trabalho em segundo plano deve ser agradável, continuar leve e seguir as preferências, certificando-se de que o impacto seja proporcional ao valor que você está entregando. Mesmo quando todos os processos do sistema adotam todos esses princípios, eles ainda são executados em um ambiente complexo e altamente dinâmico. Itens como disponibilidade da rede, carga da CPU, atividade do dispositivo, estado térmico e nível da bateria são usados como contexto para informar as decisões de programação. Felizmente, o sistema é responsável por essas condições difíceis, proporcionando a melhor experiência o tempo todo. Isso significa que mesmo tarefas bem-projetadas poderão ser adiadas se as condições não estiverem certas, otimizando o panorama geral. É essencial manter a capacidade de adaptação. Mantenha seu trabalho rápido e leve enquanto anuncia claramente suas necessidades. Projetar cargas de trabalho para continuar de onde pararam permite um progresso incremental à medida surgem as oportunidades de tempo de execução. Quanto mais você entender e se adaptar às condições e prioridades do sistema, mais bem-sucedidas serão suas cargas de trabalho.
Eficiência, minimalismo, resiliência, bom desempenho e adaptação. Esses são os principais pontos para criar um trabalho em segundo plano que se ajuste corretamente à plataforma. Pode ser útil fazer algumas perguntas importantes durante o desenvolvimento. Quem iniciou a tarefa? O trabalho foi explicitamente iniciado ou é algo arbitrário que poderia ser executado em um momento posterior? Quanto tempo demora o trabalho? Tente categorizar a duração das tarefas como curtas, médias e longas. O trabalho é fundamental para o estado e o frescor do app? Os downloads em segundo plano aumentam a sensação de vigor do app, mas os carregamentos de telemetria não trazem benefícios imediatos para o proprietário do dispositivo. Finalmente, o trabalho requer consentimento ou entrada? O tempo de execução em segundo plano não é apropriado para esses tipos de carga de trabalho, então recomendo adotar outra abordagem, se for o caso. Com essa base, vamos explorar como você pode projetar suas tarefas com eficiência. O iOS fornece diversas APIs que permitem solicitar o tempo de execução em segundo plano, e cada API assume um tipo ou perfil distinto, dependendo do suporte do trabalho. Com isso, o sistema pode ajustar o tempo de execução do app conforme as restrições e condições de que falei antes. Por exemplo, as pessoas esperam que os apps usados com mais frequência sempre tenham o melhor e mais recente conteúdo. Faz sentido para o sistema entender os padrões de uso do app, otimizando as tarefas em segundo plano e o suporte.
É o caso da primeira API, BGAppRefreshTask.
Os apps podem usá-la para buscar silenciosamente conteúdo de servidores momentos antes do uso, enquanto adotam um bom desempenho. O sistema alinha essas tarefas com o histórico de uso do app. Apps usados com frequência têm maior chance de serem agendados, garantindo novos conteúdos cada vez que são iniciados.
Para criar uma tarefa de atualização de app no SwiftUI, adicione o modificador BackgroundTask a uma cena. Quando o sistema ativar o app em segundo plano, ele invocará o fechamento, suspendendo o app quando o fechamento retornar. Embora as tarefas de atualização incluam casos de uso baseados em busca, convém manter também documentos remotos que são atualizados com pouca frequência ou de modo irregular. As notificações por push em segundo plano são uma solução pertinente. Quando o servidor envia uma notificação sobre um novo conteúdo, o sistema desperta o app em um momento adequado para buscá-la. Isso é diferente do caso de atualização do app. Aqui, uma atualização é enviada para o dispositivo em vez de buscar dados de forma oportunista. Como as notificações por push em segundo plano são usadas para indicar novos conteúdos remotos, elas são sempre consideradas arbitrárias. Elas também são enviadas com baixa prioridade e aglutinadas para minimizar as despesas gerais e o custo de energia. Quando alguém remove o app do seletor de apps, o sistema respeita essa intenção. As notificações não são entregues ao app até que ele seja aberto novamente. Às vezes, porém, convém que o app execute outros tipos de trabalho. Talvez você queira executar um modelo de aprendizado de máquina nos dados gerados ou lidar com a manutenção do banco de dados. A API BGProcessingTask permite fazer exatamente isso. Registrar-se para a tarefa é simples. Basta um identificador de tarefa, uma fila de retorno de chamada e um fechamento chamado no tempo de execução.
Você deve registrar BackgroundTasks imediatamente durante a inicialização. Dessa forma, o sistema é prontamente informado da tarefa caso ela seja iniciada em segundo plano, invocando o manipulador imediatamente. As tarefas de processamento também oferecem suporte a configurações adicionais em busca dos princípios que abordei anteriormente. Por exemplo, se o trabalho não for particularmente sensível à latência, uma grande tarefa poderá ser executada apenas quando o dispositivo estiver no carregador e conectado à rede. Isso minimiza o impacto da bateria, reduzindo o espaço ocupado e os ajustes da bateria do app. Até agora, falei sobre as APIs que permitem que o app tenha tempo de execução para tarefas que começam em segundo plano. Mas às vezes convém ter um pouco mais de tempo para continuar a execução enquanto ocorre a transição para o segundo plano. As APIs de tarefas em segundo plano de início e fim permitem que o app conclua um trabalho que pode ser irrecuperável caso seja interrompido e deixado incompleto. Vejamos um simples salvamento de estado, por exemplo. Dependendo do trabalho, o encerramento prematuro pode levar a uma experiência ruim. Encapsular o código nessas chamadas de API indica para o sistema que o app está processando um trabalho importante que não deve ser interrompido. A API é uma ótima opção quando você está limpando identificadores de arquivo ou fechando conexões de banco de dados. O cenário de suporte em segundo plano no iOS é vasto, projetado para lidar com diversas tarefas, incluindo aquelas iniciadas pelo usuário. Garantir que essas operações iniciadas pelo usuário sejam concluídas de forma confiável é essencial para uma ótima experiência. Em um iPadOS e iOS 26, a tarefa de processamento contínuo de BG fornece ao app uma forma de oferecer suporte justamente a esses recursos. Essa tarefa permite que continuar o trabalho mesmo depois que o app fica em segundo plano, com uma interface do sistema comunicando o progresso. Veja o app Diário, por exemplo. Ele usa a tarefa de processamento contínuo para conduzir exportações em segundo plano e exibe as atualizações de progresso no iniciador. Após a conclusão, o sistema é atualizado rapidamente e descarta automaticamente a interface. As pessoas continuam no controle. Elas podem consultar o andamento da tarefa e cancelar o trabalho a qualquer momento, habilitando recursos complexos.
Continuar processando tarefas sempre começa com uma ação explícita que alguém executa no app, como um movimento ou toque em botão. Cada tarefa representa um objetivo claro e imediato que alguém deseja que o app execute, como exportar arquivos, publicar conteúdo de redes sociais ou concluir uma atualização em um acessório conectado. Essas tarefas fazem um progresso mensurável, e é fácil entender o que significa quando a tarefa é concluída. As pessoas não esperam que as tarefas comecem automaticamente, mesmo que já tenham definido uma preferência no app. Evite cargas de trabalho automáticas como manutenção, backups ou sincronização de fotos. Se uma tarefa começa sem uma ação explícita, as pessoas podem não entender o objetivo da tarefa ou o que significa o progresso. Fazer esse trabalho inesperado pode levar ao cancelamento da tarefa do app. Para essas necessidades, considere outras APIs mais adequadas. Com essas considerações em mente, é muito fácil adotar tarefas de processamento contínuo. Para começar, adicione um identificador de tarefa ao Info.plist. Você vai usar isso para registrar um manipulador de inicialização que gerencia relatórios de estado e progresso. Em seguida, basta enviar uma solicitação de tarefa quando solicitado. Vamos começar pelo identificador. Para definir isso, adicione um novo valor à matriz de identificadores do agendador de tarefas em segundo plano permitida em Info.plist, garantindo que seja prefixada com o ID de pacote do app.
Além dos identificadores estáticos, as tarefas de processamento contínuo oferecem suporte a uma nova notação curinga com um sufixo dinâmico. Os identificadores curinga sempre começam com o ID do pacote, seguido por algum contexto semântico. O novo componente aqui é o asterisco de ponto, indicando que um sufixo dinâmico será anexado ao identificador no momento do registro e do envio. Um identificador totalmente composto, usado para registrar e enviar, assume essa forma. Por enquanto, vamos ficar com algo mais estático.
Com isso selecionado, o agendador precisa saber qual código executar quando a tarefa de processamento contínuo precisar ser executada. Como antes, um fechamento fornecido ao agendador é chamado após o envio de uma solicitação de tarefa. Mas aqui está uma mudança importante. Os manipuladores de inicialização não precisam ser registrados antes para que o app termine de iniciar. Em vez disso, agora você registrará dinamicamente esses manipuladores quando a intenção de usá-los for expressa.
Assim como no Diário, é fundamental fornecer atualizações oportunas sobre a progressão da carga de trabalho. E, se essa progressão for mais lenta do que o esperado, o sistema avisará o iniciador, perguntando se ele deseja que o trabalho continue. O sistema depende dessas atualizações de progresso para gerenciar o trabalho em andamento. Como consequência, as tarefas que não informam progresso expiram, permitindo que o sistema recupere e redistribua os recursos. O app comunica ativamente essas atualizações usando o Protocolo de Relatório de Progresso. À medida que faz isso, o sistema os monitora continuamente, mostrando o progresso na interface. Agora ainda precisamos estar atentos ao fato de que o sistema poderá precisar interromper sua tarefa mais cedo se as condições mudarem. Para lidar com isso, sua tarefa deve fornecer um manipulador de expiração que será chamado quando for necessário parar. Pense no manipulador como sua chance de virar rapidamente uma variável para que a tarefa possa parar suavemente e evitar trabalho extra.
Quando sua tarefa concluir o trabalho, será essencial chamar setTaskCompleted. Isso informa ao sistema que você terminou. Certo. Falei sobre como gerenciar atualizações de progresso, lidar com possíveis interrupções e sinalizar a conclusão de uma tarefa em execução. Agora, vamos juntar tudo e criar e enviar uma solicitação de tarefa válida iniciada pelo usuário.
Comece inicializando um objeto de solicitação de tarefa. São necessárias três informações: um identificador correspondente a um item em Info.plist, um título localizado e um subtítulo localizado. É isso que o usuário vê na interface do sistema. Em seguida, você precisará fornecer uma estratégia de envio a ser cumprida pelo sistema. Por padrão, se o sistema achar que não é possível executar imediatamente sua tarefa de processamento contínuo, ele a adicionará ao fim da fila. Você não precisa especificar nada mais. No entanto, às vezes a fila não é a abordagem certa. E se a tarefa só for útil se começar agora? Em vez de deixá-la na fila, você pode solicitar a falha no envio ao sistema se ele não puder iniciar imediatamente. Isso fornece um feedback instantâneo ao seu app, permitindo que você lide com a situação adequadamente.
Depois de decidir sua estratégia e configurar a solicitação, basta enviá-la ao agendador e deixar que o sistema gerencie a carga de trabalho. Esse é o processo principal ao trabalhar com tarefas de processamento contínuo. Ao fornecer o título e o subtítulo e considerar a estratégia de envio, você se integra perfeitamente com o sistema, mantendo o princípio fundamental do consentimento. A API oferece ainda mais recursos do que parece. No iPadOS e no iOS 26, suas tarefas contínuas de processamento também podem se beneficiar do acesso em segundo plano à GPU em dispositivos compatíveis. Para aproveitar isso, adicione o recurso de GPU em segundo plano nos ajustes do projeto do Xcode. Depois disso, você pode e deve, dinamicamente, consultar a propriedade de recursos suportados do agendador. Isso permite que o app entenda exatamente o que o dispositivo atual suporta no tempo de execução para poder adaptar seus requisitos de tarefa adequadamente. Essa verificação é importante. O sistema impõe esses requisitos. Qualquer solicitação de recursos indisponíveis será rejeitada após o envio, mantendo o sistema e sua tarefa em um estado íntegro e conhecido. Finalmente, lembre-se do contexto mais amplo das prioridades do sistema. O iOS prioriza a experiência em primeiro plano, o que significa que sua tarefa em segundo plano pode receber um serviço de qualidade inferior comparativamente quando o app está ativo. No entanto, o sistema é inteligente sobre isso. Quando o app volta ao primeiro plano, ele aumenta de forma inteligente sua prioridade de tarefas, ajudando a garantir que tudo continue fluido e responsivo. Essas novas APIs habilitam os recursos de execução em segundo plano mais poderosos e contínuos até agora, adicionando o BGContinuedProcessingTask indispensável ao seu kit de ferramentas. Com uma compreensão completa dessas tarefas e de como elas se enquadram no sistema como um todo, você já pode começar a adotá-las. Mal podemos esperar para saber como você vai usar essas ferramentas para criar experiências em segundo plano mais inteligentes e eficientes. Agradeço sua participação.

import BackgroundTasks
import SwiftUI

@main
struct ColorFeed: App {
    var body: some Scene {
        WindowGroup {
            // ...
        }
        .backgroundTask(.appRefresh("com.colorfeed.wwdc25.appRefresh")) {
            await self.handleAppRefreshTask()
        }
    }
}

9:45 - Register a processing task

import BackgroundTasks
import UIKit

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        BGTaskScheduler.shared.register(
            forTaskWithIdentifier: "com.example.apple-samplecode.ColorFeed.db_cleaning",
            using: nil
        ) { task in
            self.handleAppRefresh(task: task as! BGProcessingTask)
        }
    }

    func submitProcessingTaskRequest() {
        let request = BGProcessingTaskRequest(
            identifier: "com.example.apple-samplecode.ColorFeed.db_cleaning"
        )
        request.requiresNetworkConnectivity = true
        request.requiresExternalPower = true

        BGTaskScheduler.shared.submit(request)! 
    }
}

10:51 - Begin and end background task

import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid
   
    func saveState() { /*  ... */ }

    func handlePersistence() {
        let app = UIApplication.shared
        guard backgroundTaskID != .invalid else { return }
        backgroundTaskID = app.beginBackgroundTask(withName: "Finish Export") {
            app.endBackgroundTask(self.backgroundTaskID)
            self.backgroundTaskID = .invalid
        }

        self.saveState()

        app.endBackgroundTask(backgroundTaskID)
        backgroundTaskID = .invalid
    }
}

14:00 - Continued processing task registration

import BackgroundTasks

func handleDialogConfirmation() {
    BGTaskScheduler.shared.register("com.colorfeed.wwdc25.userTask") { task in
        let task = task as! BGContinuedProcessingTask
                                                                      
        var shouldContinue = true
        task.expirationHandler = {
            shouldContinue = false
        }

        task.progress.totalUnitCount = 100
        task.progress.completedUnitCount = 0

        while shouldContinue {
            // Do some work
            task.progress.completedUnitCount += 1
        }

        task.setTaskCompleted(success: true)
    }
}

15:47 - Continued processing task submission

import BackgroundTasks

func submitContinuedProcessingTaskRequest() {
    let request = BGContinuedProcessingTaskRequest(
        identifier: "com.colorfeed.wwdc25.userTask",
        title: "A succinct title",
        subtitle: "A useful and informative subtitle"
    )

    request.strategy = .fail

    BGTaskScheduler.shared.submit(request)!
}

- 0:00 - Apresentação
- Saiba como os apps podem usar o tempo de execução em segundo plano para executar tarefas como pré-busca e sincronização no seu app.
- 1:22 - Introdução
- Os apps são carregados na memória, ficam em primeiro plano e passam a ser o foco principal. Quando o usuário sai de um app, esse app vai para segundo plano e o sistema o suspende a fim de economizar bateria e recursos. Talvez o app precise de um tempo curto para concluir as tarefas. Ao retornar, ele é retomado para o primeiro plano.
- 2:09 - Comportamentos e restrições
- No iOS e no iPadOS, o tempo de execução em segundo plano é gerenciado com rigor para priorizar a duração da bateria e otimizar o desempenho. A execução em segundo plano é oportunista e opcional, e a energia é a restrição mais fundamental. Você deve projetar as tarefas em segundo plano do seu app para que sejam eficientes, leves e orientadas por objetivos. O sistema une o trabalho e pode limitar, suspender ou encerrar os processos que apresentam alto consumo de recursos. Mantenha o mínimo de trabalho em segundo plano, adie as tarefas que não são essenciais até o carregamento e garanta o caráter atômico e resiliente das tarefas. Os apps devem ser cordiais, respeitando as preferências das pessoas e as condições do sistema. O sistema oferece transparência aos usuários, permitindo que eles influenciem as decisões de programação. O sucesso das cargas de trabalho em segundo plano depende da adaptabilidade e do alinhamento delas às prioridades do sistema.
- 7:29 - APIs de tarefas em segundo plano
- O iOS e o iPadOS oferecem várias APIs para projetar tarefas executadas em segundo plano. O sistema otimiza essas tarefas com base nos padrões de uso do app e nas restrições do dispositivo. “BGAppRefreshTask” permite que os apps busquem conteúdo de forma silenciosa antes do uso, e os apps usados com mais frequência recebem programação mais frequente. As notificações por push em segundo plano ativam o app para que busque conteúdo novo quando o servidor envia uma notificação, mas essas notificações são consideradas opcionais e de baixa prioridade a fim de minimizar a sobrecarga. “BGProcessingTask” possibilita que os apps executem trabalhos mais complexos, como a execução de modelos de ML ou a manutenção de bancos de dados. Essa tarefa precisa ser registrada durante a inicialização, e é possível configurá-la para ser executada apenas quando o dispositivo estiver em um carregador e conectado a uma rede. As APIs beginBackgroundTask e endBackgroundTask oferecem mais tempo para que os apps concluam trabalhos cruciais, como salvar o estado ou encerrar conexões, ao fazer a transição para o segundo plano.
- 11:23 - Tarefas de processamento contínuo
- No iPadOS e no iOS 26, há uma nova API BGContinuedProcessingTask que permite que os apps concluam as tarefas iniciadas por alguém em primeiro plano, mesmo depois de terem sido colocados em segundo plano. Esse recurso aprimora a experiência ao permitir que o app conclua tarefas complexas sem que esteja aberto. Por exemplo, o app Diário usa essa API para exportar arquivos em segundo plano. Alguém inicia a exportação com um toque de botão, e o app apresenta atualizações de progresso por meio da UI do sistema. O usuário pode monitorar o progresso e cancelar a tarefa a qualquer momento, mantendo controle total. Essas tarefas sempre precisam começar com uma ação explícita, como um toque de botão ou um gesto. Elas representam objetivos claros e imediatos, como exportar arquivos, publicar conteúdo nas redes sociais ou concluir atualizações em acessórios conectados. O sistema espera que essas tarefas tenham um progresso mensurável. É necessário registrar um manipulador de inicialização para gerenciar o estado e os relatórios de progresso. Apresente atualizações oportunas sobre o progresso da carga de trabalho usando o protocolo de relatório de progresso. Se o progresso da tarefa estiver mais lento do que o esperado, o sistema solicitará que a pessoa decida se deve continuar. Quando a tarefa for concluída, será necessário informar o sistema usando o método “setTaskCompleted”. Além disso, o app deve lidar com possíveis interrupções de forma elegante, fornecendo um manipulador de expiração. A API também concede acesso à GPU em segundo plano nos dispositivos compatíveis, possibilitando que você crie experiências mais avançadas e eficientes em segundo plano. No entanto, lembre-se de que o iOS prioriza a experiência em primeiro plano, e as tarefas em segundo plano podem receber uma qualidade de serviço inferior. Mesmo assim, o sistema aumenta de forma inteligente a prioridade da tarefa quando o app retorna ao primeiro plano.

Capítulos

Recursos