We have an existing Android Avocado Facts application created in an older Kotlin Thursdays post, but for any Android application to be seriously useful, we will have to upgrade our facts to be more than just hard-coded. Feel free to follow along with our Github repo. In this post, we will set up an Async Task like a pro!


Async Tasks in Android

Async Tasks are a lightweight threading construct given by Android OS. Being an Android-specific concept, it is not created by Java or Kotlin. Async Tasks makes most common task of doing some heavy-weight operation off main thread easy and simple.

The Android OS is able to refresh the UI 64 frames per second — to achieve this, the UI Thread, or the Main Thread, needs to be free as much as possible. Long running tasks like communicating with APIs or databases could lock up your UI thread if it is not done in a background thread. One way to achieve this is by off-loading any longer running tasks to other threads. AsyncTasks is very powerful construct provided by OS to help achieve this.[more details]

Creating an AsyncTask in Android

An AsyncTask has three generic parameter types:

AsyncTask<Params, Progress, Result> 
- params: the type of the parameters sent to the task upon execution
- progress: the type of the progress units published during the background computation
- result: the type of the result of the background computation

We can actually think about implementing our Async tasks in the order these parameter types are defined!

Step 1:

We must analyze if any runtime parameters need to be sent for execution of the task. In our example to generate a new fact, we only need to invoke the function. Hence, the param type is Void.

Step 2:

Do we need to know about the progress percentage of this task?

In our async task, there is no concept of progress hence the progress type is also Void. One example where this is crucial will be downloading a big file.

Step 3:

What is the result of task? The type we designate here also tells us how will we can update our UI with the result. In particular, we want to show the user new fact which is of type String.

All these steps gives us our signature

AsyncTask<Void, Void, String>() {

Step 4:

Start by extending the abstract class and implementing minimum

override fun doInBackground(vararg params: Void?): String {

Step 5:

Any ui update if need will need.

Shortcut tip: ctrl + o (override method shortcut in android studio) will help do method setup
override fun onPostExecute(result: String?) {

Here we need to set result string as Textview’s text value. We have method in activity that will update it for us. So to call it we need to pass that to task so it can call it. Changing class to have

private class NewAvocadoFactTask(val activity: MainActivity)

Okay! Now just call is left

Step 6:

In onClick method call

moarButton.setOnClickListener {

Now for the MOST important step: you are leaking your activity!

How?? What??

AsyncTask is a threading construct. AsyncTask started a new thread and it doesn’t know your app may or may not have been killed by the time we have our response. In other words, AsyncTask runs independent of the main app in the background thread. So if the app is closed first without first ending the task, that task could still be running. After the response is returned, AsyncTask is responsible for returning the result to the main thread itself as a callback.

Is passing the actual activity val activity: MainActivity really safe? Should we try to call something that could be garbage collected?? Maybe we should use a wrapper called WeakReference.

var reference: WeakReference<MainActivity> = WeakReference(activity)

What is WeakReference? Glad you asked. It is a wrapper type that would be ok if the object it was keeping track of was garbage collected. Incase that happens it will indicate you the object you wanted reference for is no longer present.

reference.get() will yield a null. So we make our UI update call with elvis operator



  1. Always pass any context in AsyncTask with WeakReference Wrapper
var reference: WeakReference<MainActivity> = WeakReference(activity)

2. Use OnProgressUpdate() and OnPostExecute() to show something on UI

override fun onPostExecute(result: String?) {
Log.v(tag,”onPostExecute is running on ${Thread.currentThread().name}”)
result?.let {
// if reference.get is not null execute the function

Logging will help you see which functions are executed on Main thread since UI elements can only be touched by Main thread.

3. Always create a new Task object for a execute.

moarButton.setOnClickListener {

From threading rules of Async Task

The task can be executed only once (an exception will be thrown if a second execution is attempted.)

You can see the complete Github repo here:

We’ve set up our Async Task, but we actually need the request for the task to connect to a database so we can grab our Avocado Facts. In the next post, we will set up a database in Firebase and get our Async Task connected! See you next week.

Views: 16

Happy 10th year, JCertif!


Welcome to Codetown!

Codetown is a social network. It's got blogs, forums, groups, personal pages and more! You might think of Codetown as a funky camper van with lots of compartments for your stuff and a great multimedia system, too! Best of all, Codetown has room for all of your friends.

When you create a profile for yourself you get a personal page automatically. That's where you can be creative and do your own thing. People who want to get to know you will click on your name or picture and…

Created by Michael Levin Dec 18, 2008 at 6:56pm. Last updated by Michael Levin May 4, 2018.

Looking for Jobs or Staff?

Check out the Codetown Jobs group.

There's also a free Java Jobs mailing list. It's a Yahoo group so you have to create a Yahoo account to use it.


Enjoy the site? Support Codetown with your donation.

InfoQ Reading List

Article: Q&A on the Book Level Up Agile With Toyota Kata

In the book Level Up Agile With Toyota Kata, Jesper Boeg explores how to apply Toyota Kata to drive improvement in organizations that are using or striving to use agile ways of working. He shares his experience from combining agile with Toyota Kata to enable organizations to keep improving towards their goals.

By Ben Linders, Jesper Boeg

Presentation: The Trouble with Memory

Kirk Pepperdine takes a look at the telltale signs that a JVM based application is in the 60% memory inefficiency area, and demonstrates the steps one can take to attack this problem.

By Kirk Pepperdine

Article Series - .NET Core 3

In this series, we explore the benefits of .NET Core and how it can help not only traditional .NET developers, but all technologists who need to bring robust, performant and economical solutions to market.

By Chris Woodruff

What Tech for Good is and Why it Matters

Tech for Good groups provide opportunities to connect with people who share a positive vision of the future and look for ways to use technology in order to have a positive impact. Ellen Ward spoke about Tech for Good Dublin at Women in Tech Dublin 2019; she presented what Tech for Good looks like in reality, why it matters, and how people can get involved.

By Ben Linders

© 2019   Created by Michael Levin.   Powered by

Badges  |  Report an Issue  |  Terms of Service