WorkManager — ano ito, API at pag-iskedyul ng mga gawain

Paano gumagana ang WorkManager?

Ang arkitektura ng WorkManager ay binuo sa paligid ng tatlong base class: Worker, WorkRequest at WorkManager. Ang Worker ay naglalaman ng lohika ng gawain, ang WorkRequest ay naglalarawan ng mga parameter ng pagpapatupad, at ang WorkManager ay namamahala sa pila at pag-iskedyul. Ang library ay gumagamit ng panloob na Room database para sa pag-iimbak ng estado ng lahat ng gawain.

Worker at WorkRequest

Worker — ay isang abstract class na may iisang pamamaraang doWork, na tinatawag sa isang background thread. Ang pamamaraan ay nagbabalik ng ListenableWorker.Result — SUCCESS, FAILURE o RETRY. Ang WorkRequest ay nag-uugnay ng Worker sa mga parameter: timeout, tag, paunang pagkaantala, at mga limitasyon.

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

    override fun doWork(): Result {
        return try {
            val api = RetrofitClient.api
            val response = api.syncData()
            Result.success()
        } catch (e: Exception) {
            Result.retry()
        }
    }
}

Pag-iskedyul sa pamamagitan ng WorkManager

WorkManager ay nag-iiskedyul ng mga gawain nang pare-pareho anuman ang bersyon ng Android. Kapag tinawag ang enqueue, iniimbak ng library ang gawain sa Room, sinusuri ang kasalukuyang mga kondisyon, at pinipili ang pinakamainam na oras ng pagsisimula. Sa ilalim ng hood, maaaring gamitin ang JobScheduler, AlarmManager, o sariling scheduler — hindi na kailangang isipin ito ng developer.

val syncRequest = OneTimeWorkRequestBuilder<SyncWorker>()
    .setInitialDelay(15, TimeUnit.MINUTES)
    .addTag("sync")
    .build()

WorkManager.getInstance(context)
    .enqueue(syncRequest)

Mga Uri ng WorkRequest

WorkManager ay sumusuporta sa dalawang uri ng mga kahilingan sa pagpapatupad: isang beses at panaka-nakang. Ang pagpili ng uri ay depende sa sitwasyon: ang gawain ay dapat isagawa nang isang beses o paulit-ulit sa isang tiyak na interval.

OneTimeWorkRequest

OneTimeWorkRequest ay para sa mga gawaing dapat isagawa nang isang beses. Ito ay maaaring pagpapadala ng log, pag-sync ng data pagkatapos ng awtorisasyon, pag-load ng configuration sa unang pagtakbo. Ang pagkaantala ay itinatakda sa pamamagitan ng setInitialDelay, at mga limitasyon sa pamamagitan ng setConstraints.

PeriodicWorkRequest

PeriodicWorkRequest ay angkop para sa mga paulit-ulit na gawain na may minimum na interval na 15 minuto. Ginagarantiyahan ng library na ang interval sa pagitan ng mga pagpapatupad ay hindi bababa sa tinukoy, ngunit maaaring mas mahaba dahil sa mga limitasyon ng device. Para sa mga gawaing may dalas na mas mababa sa 15 minuto, gamitin ang Handler o Timer sa Foreground Service.

Pag-set up ng mga limitasyon at chain ng gawain

Mga limitasyon (constraints) sa WorkManager ay nagbibigay-daan sa pagtatakda ng mga kondisyon kung saan maaaring simulan ang isang gawain: koneksyon sa network (NetworkType), antas ng baterya (batteryNotLow), estado ng storage (StorageNotLow) at idle mode (DeviceIdle). Hindi magsisimula ang gawain hangga't hindi natutugunan ang lahat ng limitasyon.

val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED)
    .setRequiresCharging(true)
    .setRequiresBatteryNotLow(true)
    .build()

val request = OneTimeWorkRequestBuilder<ImageUploadWorker>()
    .setConstraints(constraints)
    .build()

Mga chain (chaining) ay nagbibigay-daan sa pag-oorganisa ng sunod-sunod o parallel na pagpapatupad ng mga gawain. Sinisimulan ng beginWith ang chain, ang then ay nagdaragdag ng susunod na Worker na isasagawa pagkatapos ng matagumpay na pagkumpleto ng nauna. Para sa parallel na pagpapatupad, gamitin ang workManager.enqueue(listOf(request1, request2)).

WorkManager.getInstance(context)
    .beginWith(compressWorker)
    .then(uploadWorker)
    .then(cleanupWorker)
    .enqueue()
    // compress -> upload -> cleanup nang sunud-sunod

Paglipat mula sa JobScheduler patungong WorkManager

JobScheduler ay ipinakilala sa Android 5 (API 21) bilang isang system service para sa pag-iskedyul ng mga background na gawain. Dumating ang WorkManager bilang kapalit na may cross-platform API, awtomatikong paglipat, at karagdagang mga kakayahan: mga chain, garantiya ng pagpapatupad, mga tag, pagsubaybay sa estado sa pamamagitan ng LiveData.

Sa paglipat mula sa JobScheduler patungong WorkManager, kailangang i-convert ang JobService sa Worker, palitan ang JobInfo ng WorkRequest, at ang Context.getSystemService ng WorkManager API. Awtomatikong nilulutas ng WorkManager ang mga problema sa compatibility at pinangangasiwaan ang Doze Mode nang mas tama kaysa sa manu-manong pagpapatupad ng JobScheduler. Mga hakbang sa paglipat: 1) gumawa ng Worker class, 2) bumuo ng WorkRequest na may parehong kondisyon, 3) alisin ang JobService at JobInfo mula sa code at manifest.

UniqueWork para sa mga natatanging gawain

Sinusuportahan ng WorkManager ang konsepto ng mga natatanging gawain sa pamamagitan ng ExistingWorkPolicy. Kung mayroon nang gawain na may tinukoy na pangalan, tinutukoy ng patakaran ang pag-uugali: KEEP (huwag gumawa ng bago), REPLACE (palitan ang umiiral), APPEND (idagdag sa dulo ng chain) at APPEND_OR_REPLACE. Ang UniqueWorkRequest ay maginhawa para sa mga gawaing hindi dapat ma-duplicate: pag-sync ng database, pag-load ng configuration, pagpapadala ng analytics package.

WorkManager.getInstance(context)
    .enqueueUniqueWork(
        "sync_data",
        ExistingWorkPolicy.KEEP,
        syncRequest
    )

Pagproseso ng progreso at pansamantalang resulta

Sinusuportahan ng CoroutineWorker ang mekanismong setProgress na nagpapahintulot sa pagpasa ng mga pansamantalang resulta ng isang gawain. Ito ay kapaki-pakinabang para sa mahabang operasyon: pag-load ng malaking file, batch processing ng mga larawan, paglipat ng database. Ang UI ay maaaring mag-subscribe sa mga update sa pamamagitan ng getWorkInfosByTagLiveData at magpakita ng progreso sa real-time. Mayroon ding ForegroundInfo na paraan para sa pagsisimula ng Worker bilang Foreground Service na may notification kung ang gawain ay dapat makita ng user.

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

    override suspend fun doWork(): Result {
        val total = 100
        for (i in 1..total) {
            setProgress(
                workDataOf("progress" to i)
            )
        }
        return Result.success()
    }
}

InputData at OutputData para sa paglipat ng datos

Sinusuportahan ng WorkManager ang paglipat ng datos sa pagitan ng mga Worker sa pamamagitan ng InputData at OutputData. Ang InputData ay ginagawa sa yugto ng pagbuo ng WorkRequest sa pamamagitan ng Data.Builder at ipinapasa sa Worker sa pamamagitan ng inputData. Pagkatapos ng pagpapatupad, ang Worker ay bumubuo ng OutputData sa pamamagitan ng workDataOf o Data.Builder at ibinabalik ito kasama ng Result.success(outputData). Ang susunod na Worker sa chain ay tumatanggap ng outputData ng nauna bilang inputData nito. Ang datos ay iniimbak sa key-value na format na may suporta sa mga pangunahing uri: String, Int, Long, Boolean, Double. Ang maximum na laki ng Data ay 10 KB.

Sa pagsasagawa, maraming proyekto ang gumagamit ng WorkManager bilang tanging scheduler ng mga background na gawain. Inirerekomenda ng Google na ilipat ang lahat ng umiiral na JobService sa WorkManager, lalo na sa mga app na sumusuporta sa Android 4.4 (API 19) at mas mababa, kung saan hindi available ang JobScheduler at ang WorkManager ay gumagamit ng backup na mekanismo sa pamamagitan ng AlarmManager at BroadcastReceiver. Para sa pagsubok, nagbibigay ang WorkManager ng TestListenableWorkerBuilder at TestWorkerBuilder na nagpapahintulot sa pagsubok ng Worker sa JUnit tests nang walang tunay na scheduler.