How to set delay in Android?

java

prompt-engineering

multithreading

async-patterns

byAnton Shumikhin·Aug 29, 2024

Wish to build a delayed task in Android? Swear by the Handler and its postDelayed() approach for concise and effective scheduling:

new Handler(Looper.getMainLooper()).postDelayed(() -> {
    // Action delayed by 2000ms goes here
}, 2000); // Voila, 2000ms delay

Here's the fast lane answer if you're in a hurry to code that perfect UI delay.

Changing button color with a stylish delay

Present a visual effect by altering a button's background post an action. Execute it with style exploiting the Handler:

new Handler(Looper.getMainLooper()).postDelayed(() -> {
    button.setBackgroundColor(Color.GREEN); // Turn button evergreen after 2000ms delay
}, 2000); // Behold the color change post 2000ms!

Feel the power of Android, bring colors to life with android.graphics.Color constants.

Advanced methods for precision and customization

Efficient countdown maneuver using `CountDownTimer`

For meticulous control over delays, think CountDownTimer. A potent tool, it enables regular intervals of code execution along with an end action:

new CountDownTimer(30000, 1000) {
    public void onTick(long millisUntilFinished) {
        // Monitor me ticking every 1000ms
    }

    public void onFinish() {
        // Watch me erupt after 30000ms!
    }
}.start();

Quick naps with `Thread.sleep`

Thread.sleep(millis) might lure you, especially for quick protos or isolated background threads. Although, it's a sly siren! It can block the thread and you might hit an iceberg in terms of performance:

try {
    Thread.sleep(2000); // Delay for 2000ms or enjoy a 2 second nap
    // Resume work or wake up!
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
}

Power up with delay utility

Frequent delay utilizations for your app? Forge a Utils class with a tidy delay method and a DelayCallback interface:

public class Utils {
    public interface DelayCallback {
        void afterDelay();
    }

    public static void delay(long millis, DelayCallback callback) {
        new Handler(Looper.getMainLooper()).postDelayed(callback::afterDelay, millis);
    }
}

Call it, and artfully dispatch your delay commands:

Utils.delay(2000, new Utils.DelayCallback() {
    @Override
    public void afterDelay() {
        // Your code to kick in post delay slumber
    }
});

The art of tailoring `CountDownTimer`

CountDownTimer is adaptable for your whims. Uses our clock and calendar to provide flexibility for specific intervals and total durations. The secret sauce for time-based glitch-free UI delights, ensuring your app stays fresh-faced and responsive.

Multithreading and sync - a quick peek

When setting delays with CountDownTimer or Handler, remember, the delayed maneuvers still parade on the UI thread. For those marathon sessions, consider asynchronous patterns such as AsyncTask or the RxJava library to refrain from clogging the UI:

new Handler(Looper.getMainLooper()).postDelayed(() -> {
    AsyncTask.execute(new Runnable() {
        @Override
        public void run() {
            // Here's where your long-winding tasks take a hike
        }
    });
}, 2000);