Android Growth Fundamentals: The way to exchange AsyncTask with Kotlin’s Coroutines

For a really very long time in Android, in case you wanted to do something asynchronously when making an app, you’d most likely be utilizing AsyncTask. AsyncTask is an API in Android’s framework that makes it simple(ish) to run operations within the background and return values when completed. And that is smart. In contrast to Kotlin’s Coroutines, AsyncTask has been round for some time, and it is constructed proper in.

Nonetheless, each the design philosophy and implementation of AsyncTask have change into considerably outdated through the years. Due to that, Google has deprecated the AsyncTask API. You’ll be able to nonetheless use it if you’d like, however Google does not advocate doing so. Fortunately, there are a complete bunch of alternate options to AsyncTask, together with a function of the Kotlin language — coroutines.

Kotlin’s coroutines API is an extremely highly effective framework which helps you to do a complete bunch of issues. This text is barely going to scratch the floor of what is attainable. We’ll be going over the fundamentals wanted emigrate from AsyncTask to coroutines.

Including Coroutines Help

Earlier than you can begin utilizing coroutines, it is advisable truly add them to your challenge.

Including Kotlin Help

If you have already got Kotlin carried out, skip forward to the subsequent part. In any other case, you will want so as to add Kotlin assist to your challenge. Try my tutorial on including Kotlin to an current challenge for extra particulars.

Including Coroutine Libraries

In your module-level construct.gradle, embody the next dependencies.

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

Sync your challenge, and Kotlin’s coroutines will now be out there to make use of.

Utilizing Coroutines

Implementing a CoroutineScope

With a view to use coroutines, you will have to have a CoroutineScope occasion out there. A straightforward method to do that is to only implement it in your containing class.

For instance, to implement a CoroutineScope in an Exercise:

 class SomeActivity : AppCompatActivity, CoroutineScope by MainScope() {
        ...
        override enjoyable onDestroy() {
            tremendous.onDestroy()
     
           cancel()
        }
} 

It will make SomeActivity implement the CoroutineScope interface by means of the MainScope class. MainScope will deal with all implementation logic for CoroutineScope, whereas permitting you to make use of the CoroutineScope strategies. Calling cancel() in onDestroy() makes positive that no asynchronous logic continues to run after the Exercise exits.

Changing AsyncTask with Coroutines

Say you may have an AsyncTask inside an Exercise that performs a long-running operation within the background and finally returns a String. One thing like the next.

 non-public inside class SomeTask : AsyncTask<Void, Void, String>() {
    override enjoyable doInBackground(vararg params: Void): String {
        strive {
            
            Thread.sleep(10000);
        } catch (e: InterruptedException) {}
         
        return "SomeString";
    }
    override enjoyable onPostExecute(outcome: String) {
        val someTextView = findViewById(R.id.some_text_view)
        someTextView.textual content = outcome
    }
} 

Changing this with a coroutine is straightforward. Simply use the async() methodology. Kotlin’s async() runs on whichever Thread it was launched on, however does it asynchronously. This implies you possibly can replace Views and such with out having to fret about utilizing the fitting Thread.

 class SomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    ...
    non-public enjoyable doOperation() {
        async {
            
            delay(10000)
            val someTextView = findViewById(R.id.some_text_view)
            someTextView.textual content = "SomeString"
        }
    }
} 

As you possibly can see, utilizing coroutines generally is a lot less complicated than utilizing AsyncTask. You do not have to only name async() and let it do its factor, although. You’ll be able to maintain a reference to it and even look ahead to it to complete.

 val asyncJob = async {
    
}
asyncJob.await()

doSomethingElse() 

Returning values with async

You’ll be able to even return a worth from async() if you’d like. So the unique instance may change into one thing like this.

 class SomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    ...
    non-public enjoyable doOperation() {
        val asyncJob = async {
            
            delay(10000)
            
           "SomeString"
        }
        val outcome = asyncJob.await()
        val someTextView = findViewById(R.id.some_text_view)
        someTextView.textual content = outcome
    }
} 

Utilizing withContext

For comfort, Kotlin supplies withContext(). This inlines the entire await() factor and simply returns the worth to you.

 class SomeActivity : AppCompatActivity(), CoroutineScope by MainScope() {
    ...
    non-public enjoyable doOperation() {
        
        val outcome = withContext(Dispatchers.Primary) {
            delay(10000)
            "SomeResult"
        }
        val someTextView = findViewById(R.id.some_text_view)
        someTextView.textual content = outcome
  }
} 

Conclusion

The examples above are just a few primary utilization of Kotlin’s coroutines to get you began. You do not have to restrict coroutines to Actions and even something with a correct lifecycle. You’ll be able to run them principally anyplace. There are additionally extra superior operations, like selecting which Thread ought to run the asynchronous logic. This information is principally for exhibiting find out how to exchange a easy AsyncTask with a easy coroutine.

For extra particulars on how coroutines work, and how one can make use of their extra superior options, try the official Kotlin documentation.