Swift Academy · Lekcja

Zadania w tle i odświeżanie

Planowanie pracy w tle za pomocą BGTaskScheduler.

Lekcja 3 z 413 kroki

Zadania w tle i odświeżanie to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 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.

Dlaczego istnieją zadania w tle

System iOS intensywnie zawiesza aplikacje, aby oszczędzać baterię. Aby wykonywać istotne zadania w tle — odświeżać kanał lub przetwarzać pobieranie — należy planować je za pomocą BGTaskScheduler. System decyduje, kiedy je uruchomić, równoważąc potrzeby aplikacji ze zużyciem energii i wzorcami użytkowania.

import BackgroundTasks
// You request work; the system schedules it later
// at an opportune moment (charging, on Wi-Fi, etc.)

Dwa typy zadań

Istnieją dwa typy zadań: BGAppRefreshTask do krótkich, częstych aktualizacji (trwających sekundy) oraz BGProcessingTask do dłuższych i bardziej wymagających operacji (trwających minuty), takich jak konserwacja bazy danych, opcjonalnie wymagających zasilania lub sieci.

import BackgroundTasks
// BGAppRefreshTask  -> quick content refresh
// BGProcessingTask  -> long maintenance, can require
//                      external power / network

Deklarowanie identyfikatorów

Każde zadanie wymaga unikatowego identyfikatora, który należy umieścić w Info.plist pod kluczem BGTaskSchedulerPermittedIdentifiers. Bez tej deklaracji rejestracja się nie powiedzie. Należy używać ciągów w stylu reverse DNS.

// Info.plist:
// BGTaskSchedulerPermittedIdentifiers = [
//   "com.example.app.refresh",
//   "com.example.app.cleanup"
// ]
let ids = "declare every identifier in Info.plist"
_ = ids

Rejestrowanie procedury obsługi

Podczas uruchamiania należy zarejestrować procedurę obsługi dla każdego identyfikatora za pomocą BGTaskScheduler.shared.register. Musi to nastąpić przed zakończeniem uruchamiania aplikacji. Procedura obsługi zostanie wykonana, gdy system zdecyduje się później uruchomić zadanie.

import BackgroundTasks
func registerTasks() {
    BGTaskScheduler.shared.register(
        forTaskWithIdentifier: "com.example.app.refresh",
        using: nil) { task in
        handleRefresh(task as! BGAppRefreshTask)
    }
}

Przesyłanie żądania

Sama rejestracja jedynie podłącza procedurę obsługi. Aby faktycznie poprosić o uruchomienie, należy utworzyć BGAppRefreshTaskRequest, ustawić najwcześniejszą datę rozpoczęcia i wywołać submit. System traktuje tę datę jako wskazówkę, a nie gwarancję.

import BackgroundTasks
func scheduleRefresh() {
    let request = BGAppRefreshTaskRequest(
        identifier: "com.example.app.refresh")
    request.earliestBeginDate = Date(
        timeIntervalSinceNow: 15 * 60)
    try? BGTaskScheduler.shared.submit(request)
}

Zawsze planuj ponownie

Przesłane żądanie zostanie wykonane najwyżej raz. Aby odświeżanie było kontynuowane, procedura obsługi musi przesłać żądanie następnego uruchomienia przed zakończeniem działania. Najpierw należy zaplanować kolejne uruchomienie, a dopiero potem wykonać pracę, aby awaria w jej trakcie nie przerwała cyklu.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh() // queue the next run first
    // ... then perform this run's work
}

Sygnalizowanie zakończenia

Po zakończeniu należy wywołać task.setTaskCompleted(success:). Pominięcie tego wywołania marnuje przydzielony czas działania w tle i może spowodować obniżenie priorytetu przyszłych zadań. Należy przekazać informację, czy operacja się powiodła, aby system mógł dostosować harmonogram.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh()
    Task {
        let ok = await fetchLatest()
        task.setTaskCompleted(success: ok)
    }
}
func fetchLatest() async -> Bool { true }

Respektowanie procedury wygaśnięcia

System może wcześniej odebrać aplikacji czas działania. Należy ustawić task.expirationHandler, aby anulować trwające operacje i posprzątać zasoby, dzięki czemu aplikacja zakończy działanie poprawnie, jeśli czas zostanie skrócony. Należy traktować tę procedurę jak alarm informujący o zbliżającym się terminie.

import BackgroundTasks
func handle(_ task: BGAppRefreshTask) {
    let work = Task { await fetchLatest() }
    task.expirationHandler = {
        work.cancel() // stop before the OS suspends us
    }
}
func fetchLatest() async -> Bool { true }

Zadania przetwarzania z wymaganiami

W przypadku wymagających operacji BGProcessingTaskRequest umożliwia ustawienie requiresNetworkConnectivity i requiresExternalPower. System czeka na spełnienie tych warunków, dlatego długie zadania mogą działać w nocy, gdy urządzenie jest ładowane i połączone z siecią Wi-Fi.

import BackgroundTasks
func scheduleCleanup() {
    let req = BGProcessingTaskRequest(
        identifier: "com.example.app.cleanup")
    req.requiresExternalPower = true
    req.requiresNetworkConnectivity = false
    try? BGTaskScheduler.shared.submit(req)
}

Testowanie w debuggerze

Nie trzeba czekać godzinami, aż system zaplanuje zadanie. Należy wstrzymać działanie w debuggerze i uruchomić polecenie LLDB, aby natychmiast wymusić uruchomienie zarejestrowanego zadania i sprawdzić procedurę obsługi od początku do końca.

// In LLDB while paused:
// e -l objc -- (void)[[BGTaskScheduler sharedScheduler]
//   _simulateLaunchForTaskWithIdentifier:
//   @"com.example.app.refresh"]
let test = "force-launch task via LLDB"
_ = test

Pełny cykl odświeżania

Podsumowując: należy zarejestrować zadanie podczas uruchamiania, przesłać żądanie po przejściu aplikacji do tła, a w procedurze obsługi zaplanować kolejne uruchomienie, zabezpieczyć pracę procedurą wygaśnięcia, wykonać operacje asynchroniczne i zgłosić ich zakończenie.

import BackgroundTasks
func handleRefresh(_ task: BGAppRefreshTask) {
    scheduleRefresh()
    let work = Task { await fetchLatest() }
    task.expirationHandler = { work.cancel() }
    Task {
        let ok = await work.value
        task.setTaskCompleted(success: ok)
    }
}
func fetchLatest() async -> Bool { true }

Szybkie sprawdzenie

Proszę przypomnieć sobie cykl życia cyklicznego zadania odświeżania.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Nauczyli się Państwo planowania zadań w tle:

BGAppRefreshTask służy do krótkich odświeżeń, a BGProcessingTask do długotrwałej konserwacji z wymaganiami dotyczącymi zasilania lub sieci.
Należy zadeklarować identyfikatory w Info.plist, zarejestrować procedury obsługi za pomocą register podczas uruchamiania oraz przesyłać żądania za pomocą submit, ustawiając earliestBeginDate.
Należy zaplanować kolejne uruchomienie wewnątrz procedury obsługi, ustawić expirationHandler i zawsze wywoływać setTaskCompleted.
Do testowania można wymuszać uruchomienie zadań za pomocą LLDB.

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łatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Zadania w tle i odświeżanie” jest bezpłatna?

Tak — pełny tekst „Zadania w tle i odświeżanie” 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 „Zadania w tle i odświeżanie”?

Planowanie pracy w tle za pomocą BGTaskScheduler. Ć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 3 z 4.

Ile czasu zajmuje lekcja „Zadania w tle i odświeżanie”?

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

← Powrót do Swift Academy