PricingLoginStart free
Swift Academy · Lekcja

Dostawcy osi czasu i migawki

Dostarczaj zawartość widżetu w czasie.

Lekcja 2 z 413 kroki

Dostawcy osi czasu i migawki to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Zadanie providera

Widżet nigdy nie aktualizuje się sam w sposób ciągły. Zamiast tego TimelineProvider przekazuje WidgetKit harmonogram wstępnie wyrenderowanych wpisów, a system wyświetla każdy z nich we właściwym czasie. Provider odpowiada na trzy pytania: placeholder, snapshot i timeline.

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

Zgodność z TimelineProvider

Provider jest zgodny z protokołem TimelineProvider i ma powiązany typ Entry. Należy zaimplementować trzy metody; każda z nich przekazuje obiekt Context opisujący rodzinę oraz informujący, czy jest to podgląd.

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
}

Placeholder

placeholder(in:) musi zwracać natychmiast reprezentatywne dane przykładowe. System wyświetla je jako zamaskowany szkielet podczas ładowania właściwego widżetu oraz w galerii widżetów. W tej metodzie nigdy nie należy wykonywać operacji sieciowych ani dyskowych.

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

Snapshot

getSnapshot dostarcza pojedynczy wpis w przejściowych sytuacjach, takich jak podgląd w galerii widżetów. Powinien zwracać wynik szybko. Gdy context.isPreview ma wartość true, należy użyć danych przykładowych zamiast wykonywać powolne pobieranie, aby galeria wyświetlała się natychmiast.

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

Oś czasu

getTimeline to najważniejsza metoda: tworzy się w niej tablicę przyszłych wpisów i łączy ją z zasadą odświeżania w obiekcie Timeline. System renderuje każdy wpis w określonym dla niego dniu, a następnie zgodnie z zasadą prosi o nową oś czasu.

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

Zasady odświeżania

Zasada ponownego ładowania określa, kiedy WidgetKit poprosi o następną oś czasu: .atEnd po dacie ostatniego wpisu, .after(date) o określonej porze lub .never do czasu ręcznego ponownego załadowania. System ogranicza częstotliwość tych operacji, dlatego nie należy oczekiwać aktualizacji co sekundę.

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

Tworzenie przyszłych wpisów

Popularnym rozwiązaniem jest wcześniejsze obliczenie danych na kilka najbliższych godzin, aby widżet aktualizował się bez każdorazowego uruchamiania Państwa kodu. Należy generować wpisy w odstępach od chwili obecnej do przyszłości, a każdy z nich powinien zawierać dane właściwe dla danego momentu.

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
}

Asynchroniczne dane na osi czasu

Jeśli trzeba pobrać dane z sieci, należy zrobić to przed wywołaniem completion. Pracę asynchroniczną należy opakować w Task i wywołać completion dopiero po otrzymaniu danych. Trzeba działać szybko — providery mają bardzo ograniczony limit czasu.

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

Istotność i limit

WidgetKit ogranicza liczbę odświeżeń w ciągu dnia, aby oszczędzać baterię. Nie można wymusić częstych aktualizacji. Należy dostarczać kilka wpisów w każdej osi czasu i wybierać rozsądny czas ponownego ładowania; z aplikacji należy używać reloadTimelines tylko w reakcji na istotne zmiany danych.

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

Provider widżetów konfigurowalnych

W przypadku widżetu korzystającego z AppIntentConfiguration należy zamiast niego użyć AppIntentTimelineProvider. Jego metody otrzymują intencję skonfigurowaną przez użytkownika, dzięki czemu można pobrać dane dla wybranej opcji (wybranego miasta, konta itp.).

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

Składanie providera

Kompletny provider zapewnia natychmiastowy placeholder, szybki snapshot uwzględniający podgląd oraz oś czasu z wcześniej przygotowanymi wpisami i odpowiednią zasadą ponownego ładowania — dzięki temu widżet pozostaje aktualny w ramach limitu narzuconego przez system.

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

Szybkie sprawdzenie

Proszę przypomnieć sobie ograniczenie dotyczące metody placeholder.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Poznali Państwo providery osi czasu:

  • placeholder zwraca natychmiast dane przykładowe; getSnapshot zwraca jeden wpis (dane przykładowe, gdy isPreview ma wartość true); getTimeline zwraca przyszłe wpisy oraz zasadę odświeżania.
  • Zasady ponownego ładowania to .atEnd, .after(date) lub .never; system operacyjny ogranicza rzeczywistą częstotliwość odświeżeń.
  • Należy wcześniej przygotowywać wiele wpisów, a pobieranie asynchroniczne wykonywać przed zakończeniem operacji.
  • Widżety konfigurowalne korzystają z AppIntentTimelineProvider.
Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
122
Lekcje
409
Zacznij naukę bezpłatnieWyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Dostawcy osi czasu i migawki” jest bezpłatna?

Tak — pełny tekst „Dostawcy osi czasu i migawki” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Dostawcy osi czasu i migawki”?

Dostarczaj zawartość widżetu w czasie. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Dostawcy osi czasu i migawki”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Tworzenie widżetu WidgetKit
  2. Dostawcy osi czasu i migawki
  3. Przegląd rozszerzeń aplikacji
  4. App Intents i skróty
← Powrót do Swift Academy