Kuinka korvata AsyncTask Kotlinin korutiinilla

Jos jouduit tekemään jotain asynkronisesti sovelluksen luomisen aikana hyvin pitkään Androidissa, olisit todennäköisesti käyttänyt AsyncTaskia. AsyncTask on Androidin sovellusliittymä, jonka avulla on helppoa (ish) suorittaa toimintoja taustalla ja palauttaa arvot, kun se on valmis. Ja siinä on järkeä. Toisin kuin Kotlinin Coroutines, AsyncTask on ollut olemassa jonkin aikaa, ja se on sisäänrakennettu.

Sekä AsyncTaskin suunnittelufilosofia että toteutus ovat kuitenkin vanhentuneet vuosien varrella. Tästä syystä Googlella on poistanut käytöstä AsyncTask APIn. Voit silti käyttää sitä, jos haluat, mutta Google ei suosittele tekemään niin. Onneksi AsyncTaskille on olemassa koko joukko vaihtoehtoja, mukaan lukien Kotlin-kielen ominaisuus - korutiinit.

Kotlinin corutines API on uskomattoman tehokas kehys, jonka avulla voit tehdä monia asioita. Tämä artikkeli tulee vain raaputtamaan pintaa siitä, mikä on mahdollista. Käymme läpi perusasiat, joita tarvitaan siirtymiseen AsyncTaskista korutiiniin.

Korutiinituen lisääminen

Ennen kuin voit aloittaa korutiinien käytön, sinun on lisättävä ne projektiisi.

Kotlin-tuen lisääminen

Jos olet jo ottanut Kotlinin käyttöön, siirry seuraavaan osioon. Muussa tapauksessa sinun on lisättävä projektiisi Kotlin-tuki. Katso lisätietoja opetusohjelmastani Kotlinin lisäämisestä olemassa olevaan projektiin.

Korutiinikirjastojen lisääminen

Moduulitasollasi build.gradle, sisältävät seuraavat riippuvuudet.

dependencies {
 ...
 implementation 'org.jetbrains.kotlinx: kotlinx-coroutines-core: 1.5.0'
 implementation 'org.jetbrains.kotlinx: kotlinx-coroutines-android: 1.5.0'
}

Synkronoi projektisi, ja Kotlinin korutiinit ovat nyt käytettävissä.

Korutiinien käyttö

CoroutineScopen käyttöönotto

Jotta voit käyttää korutiineja, sinulla on oltava CoroutineScope-esiintymä käytettävissä. Helppo tapa tehdä tämä on toteuttaa se vain sisältävässä luokassa.

Esimerkiksi CoroutineScopen käyttöönotto aktiviteetissa:

classSomeActivity : AppCompatActivity, CoroutineScope by MainScope() {
 ...
override fun onDestroy(){
super.onDestroy()

 cancel()
 }
}

Tämä saa SomeActivityn toteuttamaan CoroutineScope-rajapinnan MainScope-luokan kautta. MainScope käsittelee kaiken CoroutineScopen toteutuslogiikan, samalla kun voit käyttää CoroutineScope-menetelmiä. Kutsumus cancel() sisään onDestroy() varmistaa, että mikään asynkroninen logiikka ei jatka toimintaansa toiminnon sulkemisen jälkeen.

AsyncTaskin korvaaminen Coroutinesilla

Oletetaan, että toiminnon sisällä on AsyncTask, joka suorittaa pitkään käynnissä olevan toiminnon taustalla ja palauttaa lopulta merkkijonon. Jotain seuraavanlaista.

private inner classSomeTask : AsyncTask() {
 override fun doInBackground(vararg params: Void): String {
try {
//Pretend this is an actual operation that takes 10 seconds and not just sleeping.
Thread.sleep(10000);
 } catch (e: InterruptedException) {}

return"SomeString";
 }
 override fun onPostExecute(result: String) {
 val someTextView = findViewById(R.id.some_text_view)
 someTextView.text = result
 }
}

Tämän korvaaminen korutiinilla on helppoa. Käytä vain async() menetelmä. Kotlinin async() toimii missä tahansa säikeessä, jossa se käynnistettiin, mutta tekee sen asynkronisesti. Tämä tarkoittaa, että voit päivittää Views-näkymät ja vastaavat ilman, että sinun tarvitsee huolehtia oikean säikeen käyttämisestä.

classSomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 ...
private fun doOperation(){
async {
//Inside coroutine scopes (like inside async here), delay is used instead of Thread.sleep.
 delay(10000)
 val someTextView = findViewById(R.id.some_text_view)
 someTextView.text = "SomeString"
 }
 }
}

Kuten näet, korutiinien käyttäminen voi olla paljon yksinkertaisempaa kuin AsyncTaskin käyttäminen. Sinun ei tarvitse vain soittaa async() ja antaa sen kuitenkin tehdä tehtävänsä. Voit pitää viittauksen siihen ja jopa odottaa sen päättymistä.

val asyncJob = async {
//Some operation
}
//Pause here until the async block is finished.
asyncJob.await()
//This won't run until asyncJob finishes, but other operations started before the job, or started from another method, can still run.
doSomethingElse()

Palauttaa arvot async

Voit jopa palauttaa arvon kohteesta async() jos haluat. Joten alkuperäisestä esimerkistä voisi tulla jotain tällaista.

classSomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 ...
private fun doOperation(){
 val asyncJob = async {
//Inside coroutine scopes (like inside async here), delay is used instead of Thread.sleep.
 delay(10000)
//Whatever the type is of the last line is what async() eventually returns.
"SomeString"
 }
 val result = asyncJob.await()
 val someTextView = findViewById(R.id.some_text_view)
 someTextView.text = result
 }
}

Käyttö kontekstin kanssa

Mukavuuden vuoksi Kotlin tarjoaa withContext(). Tämä linjaa kokonaisuuden await() asia ja vain palauttaa arvon sinulle.

classSomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
 ...
private fun doOperation(){
//Run asynchronously on the main Thread.
 val result = withContext(Dispatchers.Main) {
 delay(10000)
"SomeResult"
 }
 val someTextView = findViewById(R.id.some_text_view)
 someTextView.text = result
 }
}

Johtopäätös

Yllä olevat esimerkit ovat vain joitain Kotlinin korutiinien peruskäyttötapoja, joilla pääset alkuun. Sinun ei tarvitse rajoittaa rutiineja aktiviteetteihin tai edes mihinkään, jolla on oikea elinkaari. Voit ajaa niitä periaatteessa missä tahansa. On myös kehittyneempiä toimintoja, kuten sen valitseminen, minkä säikeen tulee suorittaa asynkroninen logiikka. Tämä opas on tarkoitettu pääasiassa osoittamaan, kuinka yksinkertainen AsyncTask korvataan yksinkertaisella korutiinilla.

Lisätietoja siitä, miten korutiinit toimivat ja kuinka voit hyödyntää niiden edistyneempiä ominaisuuksia, on osoitteessa virallinen Kotlin-dokumentaatio.