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

Views: 178

Happy 10th year, JCertif!

Notes

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…
Continue

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.

 

Enjoy the site? Support Codetown with your donation.



InfoQ Reading List

Mistral Voxtral is an Open-Weights Competitor to OpenAI Whisper and Other ASR Tools

Mistral has released Voxtral, a large language model aimed at speech recognition (ASR) applications that seek to integrate more advanced LLM-based capabilities and go beyond simple transcription. For two variants of the model, Voxtral Mini (3B) and Voxtral Small (24B), Mistral has released the weights under the Apache 2.0 license.

By Sergio De Simone

OpenAI Announces Generalist ChatGPT Agent to Take on Excel, PowerPoint, and Chrome

OpenAI's ChatGPT Agent merges advanced browsing and summarization for seamless data handling. Developers can now generate editable spreadsheets and presentations with simple prompts, integrating outputs directly into productivity tools. With impressive accuracy and connectivity, it enhances workflow efficiency while automating complex tasks, heralding a new era in AI-driven productivity.

By Andrew Hoblitzell

Presentation: Enhance LLMs’ Explainability and Trustworthiness With Knowledge Graphs

Leann Chen explains how knowledge graphs enhance LLM-based systems by providing structured data as a ground truth. She demonstrates how this approach combats critical LLM challenges such as hallucinations and the "lost-in-the-middle" phenomenon, especially within RAG applications. She also highlights the struggles of vector-based LLMs with tasks like sorting and filtering.

By Leann Chen

Amazon Launches Bedrock AgentCore for Enterprise AI Agent Infrastructure

Amazon announced the preview of Amazon Bedrock AgentCore, a collection of enterprise-grade services that help developers deploy and operate AI agents at scale across frameworks and foundation models. The platform addresses infrastructure challenges developers face when building production AI agents.

By Vinod Goje

AWS Introduces Built-in Blue-Green Deployment Capability for ECS

Amazon Web Services has launched a new built-in blue/green deployment feature for Amazon Elastic Container Service (ECS) to reduce deployment risks and eliminate the need for additional tooling. This capability allows development teams to deploy containerised applications safely whilst maintaining the ability to roll back near-instantaneously if issues arise.

By Matt Saunders

© 2025   Created by Michael Levin.   Powered by

Badges  |  Report an Issue  |  Terms of Service