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!

References

• Async Tasks-https://developer.android.com/reference/android/os/AsyncTask
• Processes and Threads in Android-https://developer.android.com/guide/components/processes-and-threads
• WeakReference-https://developer.android.com/reference/kotlin/java/lang/ref/WeakRe...
• Threading- https://developer.android.com/topic/performance/threads

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 {
  NewAvocadoFactTask(this).execute();
}

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

reference.get()?.updateAvocadoFact(it)

Gotcha(s)

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

  super.onPostExecute(result)
  result?.let {
  // if reference.get is not null execute the function
  reference.get()?.updateAvocadoFact(it)
  }
}

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 {
    NewAvocadoFactTask(this).execute()
}

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.