Swift Academy · Lección

Proveedores de líneas de tiempo y snapshots

Proporcione contenido para el widget a lo largo del tiempo.

Lección 2 de 413 pasos

Proveedores de líneas de tiempo y snapshots es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Función del proveedor

Un widget nunca se actualiza continuamente por sí solo. En su lugar, un TimelineProvider entrega a WidgetKit un calendario de entradas prerenderizadas, y el sistema muestra cada una en el momento adecuado. El proveedor responde a tres preguntas: placeholder, snapshot y timeline.

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

Adoptar TimelineProvider

Un proveedor adopta TimelineProvider con un tipo Entry asociado. Debe implementar los tres métodos; cada uno le proporciona un Context que describe la familia y si se trata de una vista previa.

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
}

El placeholder

placeholder(in:) debe devolver datos ficticios representativos al instante. El sistema lo muestra como un esqueleto con el contenido oculto mientras se carga el widget real y en la galería de widgets. No realice aquí operaciones de red ni de disco.

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

El snapshot

getSnapshot proporciona una única entrada para situaciones transitorias, como la vista previa de la galería de widgets. Debe devolverla rápidamente. Cuando context.isPreview sea true, use datos de ejemplo en lugar de una obtención lenta para que la galería responda al instante.

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())
    }
}

La línea de tiempo

getTimeline es el elemento central: debe crear un array de entradas futuras y combinarlo con una política de actualización en un Timeline. El sistema renderiza cada entrada en su fecha y después solicita una nueva línea de tiempo según la 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 actualización

La política de actualización controla cuándo solicita WidgetKit la siguiente línea de tiempo: .atEnd después de la fecha de la última entrada, .after(date) en un momento específico o .never hasta que usted la actualice manualmente. El sistema administra estas actualizaciones mediante un presupuesto, así que no espere actualizaciones 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

Crear entradas futuras

Un patrón habitual consiste en precalcular las próximas horas para que el widget se actualice sin tener que activar su código cada vez. Genere entradas a intervalos desde ahora hacia el futuro, cada una con los datos correspondientes a ese 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
}

Datos asíncronos en la línea de tiempo

Si debe obtener datos de la red, hágalo antes de llamar a completion. Encapsule el trabajo asíncrono en una Task y complete la operación solo cuando lleguen los datos. Manténgalo rápido: los proveedores tienen un límite de tiempo estricto.

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")
}

Relevancia y presupuesto

WidgetKit limita la frecuencia de actualización diaria para proteger la batería. No puede forzar actualizaciones frecuentes. Proporcione varias entradas por línea de tiempo y elija un momento razonable para la actualización; use reloadTimelines desde la app solo cuando se produzcan cambios de datos relevantes.

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

Proveedor para widgets configurables

Para un widget con AppIntentConfiguration, use AppIntentTimelineProvider. Sus métodos reciben el intent configurado por el usuario, por lo que puede obtener los datos correspondientes a la opción elegida (la ciudad, la cuenta, etc.).

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

Integrar el proveedor

Un proveedor completo ofrece un placeholder instantáneo, un snapshot rápido que tiene en cuenta las vistas previas y una línea de tiempo de entradas preparadas de antemano con una política de actualización adecuada, de modo que el widget se mantenga actualizado dentro del presupuesto del 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

Comprobación rápida

Recuerde la restricción del método placeholder.

Responde en la lección interactiva

Resumen

Ha aprendido sobre los proveedores de líneas de tiempo:

placeholder devuelve datos ficticios al instante; getSnapshot devuelve una entrada (de ejemplo cuando isPreview es true); getTimeline devuelve entradas futuras y una política.
Las políticas de actualización son .atEnd, .after(date) o .never; el sistema operativo administra las actualizaciones reales mediante un presupuesto.
Prepare varias entradas de antemano y realice las obtenciones asíncronas antes de completar la operación.
Los widgets configurables usan AppIntentTimelineProvider.

Gratis para empezar

Aprende Swift con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 122
Lecciones: 409

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Proveedores de líneas de tiempo y snapshots» es gratis?

Sí — el texto completo de «Proveedores de líneas de tiempo y snapshots» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Proveedores de líneas de tiempo y snapshots»?

Proporcione contenido para el widget a lo largo del tiempo. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Proveedores de líneas de tiempo y snapshots»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Cómo crear un widget con WidgetKit
Proveedores de líneas de tiempo y snapshots
Descripción general de las extensiones de apps
App Intents y Shortcuts

← Volver a Swift Academy