The Project | About Us | Contribute | Donations | License

HOME

In this section, we will explore how to handle background tasks in Android. Background tasks are essential for performing operations that might take a long time to complete, such as network requests, file I/O, or complex computations, without blocking the main UI thread. This ensures a smooth and responsive user experience.

Key Concepts

Main Thread (UI Thread): The thread responsible for handling UI updates and user interactions.
Background Thread: A separate thread used to perform long-running operations to avoid blocking the main thread.
AsyncTask: A class that allows performing background operations and publishing results on the UI thread without having to manipulate threads and handlers.
Handler and HandlerThread: Classes that allow you to send and process Message and Runnable objects associated with a thread's MessageQueue.
WorkManager: A library that provides a unified API for deferrable, guaranteed background work.

Using AsyncTask

AsyncTask is a helper class that simplifies the creation of background tasks. It is designed to be a quick and easy way to offload work from the main thread.

Example

import android.os.AsyncTask;
import android.widget.TextView;

public class MyAsyncTask extends AsyncTask<Void, Void, String> {
    private TextView textView;

    public MyAsyncTask(TextView textView) {
        this.textView = textView;
    }

    @Override
    protected String doInBackground(Void... voids) {
        // Simulate a long-running task
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Task Completed!";
    }

    @Override
    protected void onPostExecute(String result) {
        // Update the UI with the result
        textView.setText(result);
    }
}

Usage

TextView textView = findViewById(R.id.textView);
new MyAsyncTask(textView).execute();

Explanation

doInBackground(): Runs on a background thread. This is where you put the code for the long-running task.
onPostExecute(): Runs on the main thread. This is where you update the UI with the result of the background task.

Using Handler and HandlerThread

Handlers and HandlerThreads provide a more flexible way to manage background tasks.

Example

import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.widget.TextView;

public class MyHandlerThread extends HandlerThread {
    private Handler handler;
    private TextView textView;

    public MyHandlerThread(String name, TextView textView) {
        super(name);
        this.textView = textView;
    }

    @Override
    protected void onLooperPrepared() {
        handler = new Handler(getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Simulate a long-running task
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // Update the UI
                textView.post(() -> textView.setText("Task Completed!"));
            }
        };
    }

    public void startTask() {
        handler.sendEmptyMessage(0);
    }
}

Usage

TextView textView = findViewById(R.id.textView);
MyHandlerThread handlerThread = new MyHandlerThread("MyHandlerThread", textView);
handlerThread.start();
handlerThread.startTask();

Explanation

HandlerThread: A thread with a Looper that processes Message and Runnable objects.
Handler: Used to send and process Message and Runnable objects associated with a thread's MessageQueue.

Using WorkManager

WorkManager is the recommended solution for deferrable, guaranteed background work.

Example

import android.content.Context;
import androidx.annotation.NonNull;
import androidx.work.Worker;
import androidx.work.WorkerParameters;
import androidx.work.OneTimeWorkRequest;
import androidx.work.WorkManager;

public class MyWorker extends Worker {

    public MyWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    @NonNull
    @Override
    public Result doWork() {
        // Simulate a long-running task
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return Result.failure();
        }
        return Result.success();
    }
}

Usage

OneTimeWorkRequest workRequest = new OneTimeWorkRequest.Builder(MyWorker.class).build();
WorkManager.getInstance(context).enqueue(workRequest);

Explanation

Worker: A class that performs the background work.
WorkManager: A library that schedules and runs the background work.

Practical Exercise

Task

Create an Android app that uses WorkManager to perform a background task that simulates downloading a file. Update the UI to show the progress and completion status.

Solution

Create a Worker Class

import android.content.Context;
import androidx.annotation.NonNull;
import androidx.work.Worker;
import androidx.work.WorkerParameters;

public class DownloadWorker extends Worker {

    public DownloadWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    @NonNull
    @Override
    public Result doWork() {
        // Simulate file download
        for (int i = 0; i <= 100; i += 10) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                return Result.failure();
            }
            // Update progress (this is a simplified example)
            setProgressAsync(new Data.Builder().putInt("progress", i).build());
        }
        return Result.success();
    }
}

Enqueue the Work Request

import androidx.work.OneTimeWorkRequest;
import androidx.work.WorkManager;

OneTimeWorkRequest downloadRequest = new OneTimeWorkRequest.Builder(DownloadWorker.class).build();
WorkManager.getInstance(context).enqueue(downloadRequest);

Observe the Work Status

import androidx.lifecycle.Observer;
import androidx.work.WorkInfo;

WorkManager.getInstance(context).getWorkInfoByIdLiveData(downloadRequest.getId())
    .observe(this, new Observer<WorkInfo>() {
        @Override
        public void onChanged(WorkInfo workInfo) {
            if (workInfo != null) {
                if (workInfo.getState() == WorkInfo.State.SUCCEEDED) {
                    textView.setText("Download Completed!");
                } else if (workInfo.getState() == WorkInfo.State.RUNNING) {
                    int progress = workInfo.getProgress().getInt("progress", 0);
                    textView.setText("Download Progress: " + progress + "%");
                }
            }
        }
    });

Summary

In this section, we covered the basics of working with background tasks in Android. We explored different methods, including AsyncTask, Handler and HandlerThread, and WorkManager. Each method has its use cases and advantages. WorkManager is the recommended approach for most background tasks due to its flexibility and reliability. By understanding and utilizing these tools, you can ensure that your app remains responsive and provides a smooth user experience.

Working with Background Tasks

Key Concepts

Using AsyncTask

Example

Usage

Explanation

Using Handler and HandlerThread

Example

Usage

Explanation

Using WorkManager

Example

Usage

Explanation

Practical Exercise

Task

Solution

Summary

Android Studio Course

Module 1: Introduction to Android Studio

Module 2: Basic Android Development

Module 3: Intermediate Android Development

Module 4: Advanced Android Development

Module 5: Professional Android Development

Module 6: Special Topics