Swift Academy · Aula

Provedores de linha do tempo e instantâneos

Forneça conteúdo para o widget ao longo do tempo.

Aula 2 de 413 etapas

Provedores de linha do tempo e instantâneos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 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.

A função do fornecedor

Um widget nunca se atualiza continuamente sozinho. Em vez disso, um TimelineProvider fornece ao WidgetKit uma programação de entradas pré-renderizadas, e o sistema exibe cada uma no momento correto. O fornecedor responde a três perguntas: marcador de posição, instantâneo e linha do tempo.

import WidgetKit
// TimelineProvider supplies:
//   placeholder(in:) -> instant skeleton
//   getSnapshot(in:)  -> one entry for previews
//   getTimeline(in:)  -> future entries + refresh policy

Conformidade com TimelineProvider

Um fornecedor está em conformidade com TimelineProvider e tem um tipo Entry associado. Você implementa os três métodos; cada um fornece um Context que descreve a família e informa se ela é uma visualização de prévia.

import WidgetKit
struct WeatherProvider: TimelineProvider {
    typealias Entry = WeatherEntry
    func placeholder(in context: Context) -> WeatherEntry {
        WeatherEntry(date: Date(),
            temperature: 20, condition: "Sunny")
    }
    // getSnapshot and getTimeline follow
}

O marcador de posição

placeholder(in:) precisa retornar instantaneamente, usando dados fictícios representativos. O sistema o exibe como um esqueleto ocultado enquanto o widget real é carregado e na galeria de widgets. Nunca faça operações de rede ou disco aqui.

import WidgetKit
func placeholder(in context: Context) -> WeatherEntry {
    // Synchronous, fake data, no I/O
    WeatherEntry(date: Date(),
        temperature: 0, condition: "--")
}

O instantâneo

getSnapshot fornece uma única entrada para situações temporárias, como a prévia na galeria de widgets. Ele deve retornar rapidamente. Quando context.isPreview for verdadeiro, use dados de exemplo em vez de uma busca lenta, para que a galeria pareça instantânea.

import WidgetKit
func getSnapshot(
    in context: Context,
    completion: @escaping (WeatherEntry) -> Void) {
    if context.isPreview {
        completion(WeatherEntry(date: Date(),
            temperature: 22, condition: "Clear"))
    } else {
        completion(currentEntry())
    }
}

A linha do tempo

getTimeline é o elemento central: você cria uma matriz de entradas futuras e as combina com uma política de atualização em uma Timeline. O sistema renderiza cada entrada na data correspondente e depois solicita uma nova linha do tempo conforme a política.

import WidgetKit
func getTimeline(
    in context: Context,
    completion: @escaping (Timeline<WeatherEntry>) -> Void) {
    let entries = buildEntries()
    let timeline = Timeline(
        entries: entries, policy: .atEnd)
    completion(timeline)
}

Políticas de atualização

A política de recarregamento controla quando o WidgetKit solicita a próxima linha do tempo: .atEnd após a data da última entrada, .after(date) em um horário específico ou .never até que você faça o recarregamento manualmente. O sistema administra essas atualizações, portanto não espere atualizações segundo a segundo.

import WidgetKit
// .atEnd            -> reload after final entry
// .after(someDate)  -> reload at a chosen time
// .never            -> only on manual reloadTimelines
let policy = TimelineReloadPolicy.atEnd
_ = policy

Criação de entradas futuras

Um padrão comum é pré-calcular as próximas horas para que o widget seja atualizado sem reativar o seu código a cada momento. Gere entradas em intervalos que partam de agora e avancem para o futuro, cada uma contendo os dados correspondentes àquele momento.

import WidgetKit
import Foundation
func hourlyEntries() -> [WeatherEntry] {
    var entries: [WeatherEntry] = []
    let now = Date()
    for hour in 0..<6 {
        let date = Calendar.current.date(
            byAdding: .hour, value: hour, to: now)!
        entries.append(WeatherEntry(date: date,
            temperature: 18 + hour, condition: "Sunny"))
    }
    return entries
}

Dados assíncronos na linha do tempo

Se precisar buscar dados na rede, faça isso antes de chamar a conclusão. Envolva o trabalho assíncrono em uma Task e só conclua quando os dados chegarem. Mantenha a operação rápida: os fornecedores têm um limite de tempo bastante restrito.

import WidgetKit
func getTimeline(
    in context: Context,
    completion: @escaping (Timeline<WeatherEntry>) -> Void) {
    Task {
        let entry = await fetchForecast()
        let timeline = Timeline(
            entries: [entry], policy: .after(
                Date().addingTimeInterval(3600)))
        completion(timeline)
    }
}
func fetchForecast() async -> WeatherEntry {
    WeatherEntry(date: Date(),
        temperature: 21, condition: "Cloudy")
}

Relevância e limite de recursos

O WidgetKit limita a frequência de atualização por dia para preservar a bateria. Você não pode forçar atualizações frequentes. Forneça várias entradas por linha do tempo e escolha um horário razoável para o recarregamento; use reloadTimelines no aplicativo apenas quando os dados mudarem de forma relevante.

import WidgetKit
// The system, not you, decides exact refresh timing.
// Strategy: pre-bake multiple entries + a sensible policy
// + app-driven reloads on real changes.
let budget = "refreshes are budgeted by the OS"
_ = budget

Fornecedor para widgets configuráveis

Para um widget com AppIntentConfiguration, use AppIntentTimelineProvider. Os métodos dele recebem a intenção configurada pelo usuário, para que você possa buscar dados referentes à opção escolhida (a cidade, a conta e assim por diante).

import WidgetKit
// AppIntentTimelineProvider adds the configuration:
//   func timeline(for configuration: MyIntent,
//                 in context: Context)
//       async -> Timeline<Entry>
let configurable = "intent-aware provider"
_ = configurable

Montagem do fornecedor

Um fornecedor completo oferece um marcador de posição instantâneo, um instantâneo rápido que considera a prévia e uma linha do tempo de entradas pré-geradas com uma política de recarregamento apropriada — assim, o widget permanece atualizado dentro do limite de recursos do sistema.

import WidgetKit
// 1. placeholder -> instant dummy
// 2. getSnapshot -> sample when isPreview, else current
// 3. getTimeline -> [entries] + .atEnd or .after
let summary = "three methods, one current widget"
_ = summary

Verificação rápida

Relembre a restrição do método de marcador de posição.

Responda na aula interativa

Recapitulação

Você aprendeu sobre fornecedores de linhas do tempo:

placeholder retorna dados fictícios instantaneamente; getSnapshot retorna uma entrada (use dados de exemplo quando isPreview); getTimeline retorna entradas futuras e uma política.
As políticas de recarregamento são .atEnd, .after(date) ou .never; o OS administra as atualizações efetivas.
Pré-genere várias entradas; faça as buscas assíncronas antes de concluir.
Widgets configuráveis usam AppIntentTimelineProvider.

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 “Provedores de linha do tempo e instantâneos” é grátis?

Sim — o texto completo de “Provedores de linha do tempo e instantâneos” é 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 “Provedores de linha do tempo e instantâneos”?

Forneça conteúdo para o widget ao longo do tempo. 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 2 de 4.

Quanto tempo leva a aula “Provedores de linha do tempo e instantâneos”?

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

Criando um WidgetKit Widget
Provedores de linha do tempo e instantâneos
Visão geral das extensões de aplicativos
App Intents e atalhos

← Voltar para Swift Academy