Kuidas asendada AsyncTask Kotlini korutiinidega

Kui teil oli vaja Androidis väga pikka aega rakenduse loomisel midagi asünkroonselt teha, kasutasite tõenäoliselt AsyncTaski. AsyncTask on Androidi raamistikus olev API, mis muudab toimingute taustal käitamise lihtsaks ja lõpetades väärtuste tagastamise. Ja see on loogiline. Erinevalt Kotlini Coroutinesist on AsyncTask olnud juba mõnda aega ja see on sisse ehitatud.

Kuid nii AsyncTaski disainifilosoofia kui ka rakendamine on aastate jooksul mõnevõrra vananenud. Seetõttu on Google'il aegunud AsyncTask API. Soovi korral saate seda endiselt kasutada, kuid Google ei soovita seda teha. Õnneks on AsyncTaskile terve hulk alternatiive, sealhulgas Kotlini keele funktsioon - korutiinid.

Kotlini corutines API on uskumatult võimas raamistik, mis võimaldab teil teha palju asju. See artikkel kriimustab ainult võimaliku pinda. Me käsitleme põhitõdesid, mis on vajalikud AsyncTaskilt korutiinile üleminekuks.

Korutiinide toe lisamine

Enne korutiinide kasutamise alustamist peate need oma projektile lisama.

Kotlini toe lisamine

Kui olete Kotlini juba rakendanud, minge järgmise jaotise juurde. Vastasel juhul peate oma projektile lisama Kotlini toe. Lisateabe saamiseks vaadake minu õpetust Kotlini lisamise kohta olemasolevasse projekti.

Korutiini teekide lisamine

Teie mooduli tasemel build.gradle, sisaldab järgmisi sõltuvusi.

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

Sünkroonige oma projekt ja Kotlini korutiinid on nüüd kasutamiseks saadaval.

Korutiinide kasutamine

CoroutineScope'i rakendamine

Korutiinide kasutamiseks peab teil olema saadaval CoroutineScope'i eksemplar. Lihtne viis seda teha on lihtsalt juurutada see oma sisaldavas klassis.

Näiteks CoroutineScope'i rakendamiseks tegevuses:

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

 cancel()
 }
}

See paneb SomeActivity rakendama CoroutineScope'i liidest MainScope'i klassi kaudu. MainScope tegeleb kogu CoroutineScope'i juurutusloogikaga, võimaldades samal ajal kasutada CoroutineScope'i meetodeid. Helistamine cancel() sisse onDestroy() tagab, et ükski asünkroonne loogika ei tööta pärast tegevusest väljumist.

AsyncTaski asendamine korutiinidega

Oletagem, et teil on toimingu sees asyncTask, mis teostab taustal pikaajalise toimingu ja tagastab lõpuks stringi. Midagi järgmist.

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

Selle asendamine korutiiniga on lihtne. Kasutage lihtsalt async() meetod. Kotlini oma async() töötab mis tahes lõimel, millel see käivitati, kuid teeb seda asünkroonselt. See tähendab, et saate vaateid jms värskendada, ilma et peaksite muretsema õige lõime kasutamise pärast.

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

Nagu näete, võib korutiini kasutamine olla palju lihtsam kui AsyncTaski kasutamine. Sa ei pea lihtsalt helistama async() ja las ta teeb siiski oma asja. Võite hoida viidet sellele ja isegi oodata, kuni see lõpeb.

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

Väärtuste tagastamine asünkrooniga

Saate isegi väärtuse tagastada async() kui sa tahad. Nii et algsest näitest võib saada midagi sellist.

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

Kasutamine koos kontekstiga

Mugavuse huvides pakub Kotlin withContext(). See loob terviku sisse await() ja lihtsalt tagastab teile väärtuse.

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

Järeldus

Ülaltoodud näited on vaid mõned Kotlini korutiinide põhikasutusviisid, mis aitavad teil alustada. Te ei pea piirduma korutiine tegevustega ega isegi millegagi, millel on õige elutsükkel. Saate neid põhimõtteliselt kõikjal käivitada. On ka täpsemaid toiminguid, näiteks valimine, milline lõim peaks asünkroonset loogikat käivitama. See juhend on mõeldud peamiselt selleks, et näidata, kuidas asendada lihtne AsyncTask lihtsa korutiiniga.

Korutiinide toimimise ja nende täiustatud funktsioonide kasutamise kohta lisateabe saamiseks vaadake lehte ametlik Kotlini dokumentatsioon.