Android Academy · Lekcja

WorkManager i zadania w tle

Planuj gwarantowane zadania w tle za pomocą WorkManager. Używaj OneTimeWorkRequest, PeriodicWorkRequest, ograniczeń, przekazywania danych i łańcuchów zadań.

WorkManager i zadania w tle to bezpłatna lekcja Android Academy na CoddyKit. To lekcja 5 z 6. 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 Android Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Android Academy zawiera 6 lekcji w sumie.

Praca w tle w systemie Android

System Android zdecydowanie ogranicza pracę w tle, aby oszczędzać baterię. Przed wprowadzeniem WorkManager deweloperzy korzystali z:

AsyncTask (przestarzałe)
AlarmManager (niewiarygodne po ponownym uruchomieniu urządzenia i w trybie Doze)
JobScheduler (złożone API)
Usług (mogą zostać zakończone, brak ponawiania prób)

WorkManager to zalecane rozwiązanie do odraczalnej, gwarantowanej pracy w tle.

Czym jest WorkManager?

WorkManager gwarantuje wykonanie pracy nawet po zamknięciu aplikacji lub ponownym uruchomieniu urządzenia. Zapewnia:

Przechowywanie zadań mimo ponownego uruchomienia urządzenia
Automatyczne ponawianie po niepowodzeniu
Obsługę ograniczeń (tylko Wi-Fi, tylko podczas ładowania itd.)
Działanie od API 14+
Integrację z Kotlin Coroutines za pośrednictwem CoroutineWorker

Konfiguracja

Dodaj WorkManager do app/build.gradle:

dependencies {
    implementation 'androidx.work:work-runtime-ktx:2.9.0'
}

Tworzenie Workera

Rozszerz CoroutineWorker i zaimplementuj doWork(). Zwróć Result.success(), Result.failure() lub Result.retry():

class SyncWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            // This runs on a background coroutine
            val repo = UserRepository(applicationContext)
            repo.syncFromNetwork()
            Result.success()
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry()
            else Result.failure()
        }
    }
}

OneTimeWorkRequest

Zaplanuj jednorazowe zadanie i dodaj je do kolejki:

val syncWork = OneTimeWorkRequestBuilder<SyncWorker>()
    .setInitialDelay(10, TimeUnit.MINUTES)  // optional delay
    .build()

WorkManager.getInstance(context).enqueue(syncWork)

// With a unique name (prevents duplicates):
WorkManager.getInstance(context).enqueueUniqueWork(
    "sync_work",
    ExistingWorkPolicy.KEEP,   // don't enqueue if already pending
    syncWork
)

PeriodicWorkRequest

Zaplanuj zadania cykliczne. Minimalny odstęp wynosi 15 minut:

val periodicSync = PeriodicWorkRequestBuilder<SyncWorker>(
    repeatInterval = 1, TimeUnit.HOURS
).build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "hourly_sync",
    ExistingPeriodicWorkPolicy.KEEP,
    periodicSync
)

Ograniczenia

Uruchamiaj zadanie tylko wtedy, gdy spełnione są określone warunki — bateria nie jest rozładowana, urządzenie jest połączone z Wi-Fi itd.:

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.UNMETERED)  // WiFi only
    .setRequiresBatteryNotLow(true)
    .setRequiresCharging(false)
    .build()

val work = OneTimeWorkRequestBuilder<SyncWorker>()
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(context).enqueue(work)

Dane wejściowe i wyjściowe

Przekazuj dane do Workera i odbieraj je z niego za pomocą obiektów Data:

// Enqueue with input data:
val inputData = workDataOf("user_id" to 42)
val work = OneTimeWorkRequestBuilder<SyncWorker>()
    .setInputData(inputData)
    .build()

// Inside the Worker:
class SyncWorker(...) : CoroutineWorker(...) {
    override suspend fun doWork(): Result {
        val userId = inputData.getInt("user_id", -1)

        // Pass output data back:
        val output = workDataOf("synced_count" to 10)
        return Result.success(output)
    }
}

Obserwowanie stanu zadania

Obserwuj postęp zadania za pomocą getWorkInfoByIdLiveData:

val workRequest = OneTimeWorkRequestBuilder<SyncWorker>().build()
WorkManager.getInstance(this).enqueue(workRequest)

WorkManager.getInstance(this)
    .getWorkInfoByIdLiveData(workRequest.id)
    .observe(this) { info ->
        when (info?.state) {
            WorkInfo.State.RUNNING   -> binding.tvStatus.text = "Syncing..."
            WorkInfo.State.SUCCEEDED -> binding.tvStatus.text = "Done!"
            WorkInfo.State.FAILED    -> binding.tvStatus.text = "Failed"
            else                     -> {}
        }
    }

Łączenie zadań

Uruchamiaj zadania sekwencyjnie lub równolegle za pomocą łańcuchów zadań:

val downloadWork  = OneTimeWorkRequestBuilder<DownloadWorker>().build()
val processWork   = OneTimeWorkRequestBuilder<ProcessWorker>().build()
val uploadWork    = OneTimeWorkRequestBuilder<UploadWorker>().build()

// Sequential: download → process → upload
WorkManager.getInstance(context)
    .beginWith(downloadWork)
    .then(processWork)
    .then(uploadWork)
    .enqueue()

// Parallel then merge:
WorkManager.getInstance(context)
    .beginWith(listOf(downloadWork, processWork))  // both run in parallel
    .then(uploadWork)                              // runs after both finish
    .enqueue()

WorkManager a alternatywy

Kiedy używać poszczególnych rozwiązań:

WorkManager — odraczalna, gwarantowana praca oparta na ograniczeniach. Najlepszy do synchronizacji, przesyłania danych i czyszczenia.
Coroutines / ViewModel — praca powiązana z otwartą aplikacją. Zatrzymuje się po zamknięciu aplikacji.
AlarmManager — alarmy uruchamiane o dokładnie określonej porze (przypomnienia kalendarza). Wymaga starannego zarządzania baterią.
Foreground Service — długotrwałe zadania, o których użytkownik wie (odtwarzanie muzyki, nawigacja).

Szybkie sprawdzenie

Jaki jest minimalny odstęp między powtórzeniami dla PeriodicWorkRequest?

Podsumowanie: WorkManager

WorkManager jest właściwym narzędziem do gwarantowanej pracy w tle:

Rozszerz CoroutineWorker i zaimplementuj doWork()
Zwracaj Result.success(), .failure() lub .retry()
Używaj OneTimeWorkRequest dla pojedynczych uruchomień i PeriodicWorkRequest dla zadań cyklicznych
Dodawaj Constraints dla pracy tylko przez Wi-Fi, warunków baterii itd.
Przekazuj dane za pomocą workDataOf()
Łącz zadania za pomocą beginWith().then().enqueue()

Następnie: komponenty Material Design do tworzenia pięknych interfejsów.

Często zadawane pytania

Czy lekcja „WorkManager i zadania w tle” jest bezpłatna?

Tak — pełny tekst „WorkManager i zadania w tle” 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 Android Academy, przejdź na CoddyKit PRO. Kurs Android Academy zawiera 6 lekcji w sumie.

Co nauczysz się w „WorkManager i zadania w tle”?

Planuj gwarantowane zadania w tle za pomocą WorkManager. Używaj OneTimeWorkRequest, PeriodicWorkRequest, ograniczeń, przekazywania danych i łańcuchów zadań. Ćwiczysz Android 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ąć Android Academy?

Nie wymagamy żadnego doświadczenia. Android 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 5 z 6.

Ile czasu zajmuje lekcja „WorkManager i zadania w tle”?

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 Android Academy?

Tak. Każda lekcja Android 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 Android Academy