Tutorial on Android AsyncTask Example
Today, our focus will be on Android AsyncTask. We will create an Android sample application that executes a generic AsyncTask in the background.
An Android AsyncTask
The Android AsyncTask is a class provided by Android that allows us to perform demanding tasks in the background while keeping the UI thread light, resulting in a more responsive application. When an Android application is launched, it runs on a single thread. However, tasks that take a long time to retrieve a response can cause the application to become unresponsive. To prevent this, we can utilize the Android AsyncTask to execute these heavy tasks on a separate thread and send the results back to the UI thread. As a result, using AsyncTask in an Android application ensures that the UI thread remains responsive at all times. The following are the fundamental methods defined in the Android AsyncTask class:
- doInBackground() : This method contains the code which needs to be executed in background. In this method we can send results multiple times to the UI thread by publishProgress() method. To notify that the background processing has been completed we just need to use the return statements
- onPreExecute() : This method contains the code which is executed before the background processing starts
- onPostExecute() : This method is called after doInBackground method completes processing. Result from doInBackground is passed to this method
- onProgressUpdate() : This method receives progress updates from doInBackground method, which is published via publishProgress method, and this method can use this progress update to update the UI thread
Below are the three general types implemented in an Android AsyncTask class:
- 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
An illustration of an Android AsyncTask
In order to commence an AsyncTask, the MainActivity class should contain the following code snippet.
MyTask myTask = new MyTask();
myTask.execute();
In the provided code segment, a sample classname that extends AsyncTask is utilized, and the execute method is employed to initiate the background thread. Please bear in mind.
- The AsyncTask instance must be created and invoked in the UI thread.
- The methods overridden in the AsyncTask class should never be called. They’re called automatically
- AsyncTask can be called only once. Executing it again will throw an exception
In this tutorial, we will be creating an AsyncTask that allows the user to set a specific period of time for a process to go into sleep mode.
The structure of an Android Async Task project.
Code example demonstrating the use of Android AsyncTask.
The activity_main.xml file is where the xml layout is defined, and here is its content: activity_main.xml
<RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
xmlns:tools="https://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >
<TextView
android:id="@+id/tv_time"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="10pt"
android:textColor="#444444"
android:layout_alignParentLeft="true"
android:layout_marginRight="9dip"
android:layout_marginTop="20dip"
android:layout_marginLeft="10dip"
android:text="Sleep time in Seconds:"/>
<EditText
android:id="@+id/in_time"
android:layout_width="150dip"
android:layout_height="wrap_content"
android:background="@android:drawable/editbox_background"
android:layout_toRightOf="@id/tv_time"
android:layout_alignTop="@id/tv_time"
android:inputType="number"
/>
<Button
android:id="@+id/btn_run"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Run Async task"
android:layout_below="@+id/in_time"
android:layout_centerHorizontal="true"
android:layout_marginTop="64dp" />
<TextView
android:id="@+id/tv_result"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textSize="7pt"
android:layout_below="@+id/btn_run"
android:layout_centerHorizontal="true" />
</RelativeLayout>
In the layout provided, we have utilized a drawable that has been pre-set to serve as the border for the EditText. The MainActivity.java code is outlined below:
package com.scdev.asynctask;
import android.app.ProgressDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
public class MainActivity extends AppCompatActivity {
private Button button;
private EditText time;
private TextView finalResult;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
time = (EditText) findViewById(R.id.in_time);
button = (Button) findViewById(R.id.btn_run);
finalResult = (TextView) findViewById(R.id.tv_result);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
AsyncTaskRunner runner = new AsyncTaskRunner();
String sleepTime = time.getText().toString();
runner.execute(sleepTime);
}
});
}
private class AsyncTaskRunner extends AsyncTask<String, String, String> {
private String resp;
ProgressDialog progressDialog;
@Override
protected String doInBackground(String... params) {
publishProgress("Sleeping..."); // Calls onProgressUpdate()
try {
int time = Integer.parseInt(params[0])*1000;
Thread.sleep(time);
resp = "Slept for " + params[0] + " seconds";
} catch (InterruptedException e) {
e.printStackTrace();
resp = e.getMessage();
} catch (Exception e) {
e.printStackTrace();
resp = e.getMessage();
}
return resp;
}
@Override
protected void onPostExecute(String result) {
// execution of result of Long time consuming operation
progressDialog.dismiss();
finalResult.setText(result);
}
@Override
protected void onPreExecute() {
progressDialog = ProgressDialog.show(MainActivity.this,
"ProgressDialog",
"Wait for "+time.getText().toString()+ " seconds");
}
@Override
protected void onProgressUpdate(String... text) {
finalResult.setText(text[0]);
}
}
}
In the code provided, we utilized the AsyncTaskRunner class to execute the AsyncTask operations. A duration in seconds is passed as an argument to the class, and a ProgressDialog is shown for the specified duration. The attached images demonstrate the outcomes achieved from the project when the user sets a time of 5 seconds. This concludes the tutorial.