Handler Looper | Concurrency | Android Development Tutorial

Introduction

In Android development, dealing with concurrency is a critical aspect of building smooth and responsive applications. Two essential components for managing concurrency in Android are the Handler and Looper. This tutorial will guide you through understanding and implementing these components in your Android applications.

What is a Looper?

A Looper is a class used to run a message loop for a thread. Most Android applications run on a single thread, the main thread. However, sometimes you need to perform background tasks on a different thread to avoid blocking the main thread. The Looper prepares the thread to run in a loop, processing messages that are placed in its message queue.

What is a Handler?

A Handler is a utility class that allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Handlers are primarily used to communicate between threads, sending messages or runnable tasks to be executed on a specific thread.

Creating a Looper and Handler

To create a Looper and Handler, follow these steps:

class ExampleThread extends Thread {
    public Handler handler;

    @Override
    public void run() {
        // Prepare the Looper
        Looper.prepare();

        // Create the handler associated with this thread
        handler = new Handler(Looper.myLooper()) {
            @Override
            public void handleMessage(Message msg) {
                // Handle the message
                // Do background work here
            }
        };

        // Start the loop
        Looper.loop();
    }
}

In this example, we create a new thread by extending the Thread class. Inside the run method, we prepare the Looper, create a Handler, and start the message loop.

Using the Handler to Post Messages

Once you have a Handler, you can use it to post messages or runnable tasks to be executed on the thread's message queue. For example:

ExampleThread exampleThread = new ExampleThread();
exampleThread.start();

// Post a message to the Handler
exampleThread.handler.post(new Runnable() {
    @Override
    public void run() {
        // Code to execute in the background thread
    }
});

In this example, we start the ExampleThread and post a runnable task to be executed in the background thread.

Sending Messages with Handler

You can also send messages with specific data to be processed by the Handler. For example:

Message message = exampleThread.handler.obtainMessage();
message.what = 1; // Define your message type
message.obj = "Hello, Handler"; // Attach any data
exampleThread.handler.sendMessage(message);

In this example, we create a Message object, set its type and data, and send it to the Handler for processing.

Example: Updating UI from Background Thread

One common use case for Handlers is updating the UI from a background thread. Since UI updates must be performed on the main thread, you can use a Handler to post tasks to the main thread's message queue. Here’s an example:

Handler mainHandler = new Handler(Looper.getMainLooper());

new Thread(new Runnable() {
    @Override
    public void run() {
        // Perform background work here

        // Post a task to the main thread
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                // Update UI here
            }
        });
    }
}).start();

In this example, we create a Handler associated with the main thread's Looper and use it to post a UI update task from a background thread.

Conclusion

Handlers and Loopers are powerful tools for managing concurrency in Android applications. By properly utilizing these components, you can ensure your application remains responsive and provides a smooth user experience. This tutorial covered the basics of creating and using Handlers and Loopers. With this knowledge, you can efficiently handle background tasks and communicate between threads in your Android applications.

Handler and Looper in Android Development