What do I use now that Handler() is deprecated?

Question

How do I fix the deprecation warning in this code? Alternatively, are there any other options for doing this?

Handler().postDelayed({
    context?.let {
        //code
    }
}, 3000)

Nikunj Paradva · Accepted Answer · 2023-01-20T05:12:13.190

670

Only the parameterless constructor is deprecated, it is now preferred that you specify the Looper in the constructor via the Looper.getMainLooper() method.

Use it for Java

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
    @Override
    public void run() {
        // Your Code
    }
}, 3000);

Use it for Kotlin

Handler(Looper.getMainLooper()).postDelayed({
    // Your Code
}, 3000)

Source : developer.android.com

edited Jan 20 '23 at 05:12

answered Sep 11 '20 at 17:40

Nikunj Paradva

15,332
5
54
65

3

Straight forward... – Fahmi Eshaq Jan 03 '22 at 09:54
3

what is getMainLooper()? – UNREAL May 14 '22 at 13:46
2

@UNREAL Returns the application's main looper, which lives in the main thread of the application. https://developer.android.com/reference/android/os/Looper#getMainLooper() – Nikunj Paradva May 16 '22 at 03:51

score 92 · Answer 2 · edited Jul 07 '23 at 08:20

From API level 30, there are 2 constructors that are deprecated.

Google explains the reason below.

Implicitly choosing a Looper during Handler construction can lead to bugs where operations are silently lost (if the Handler is not expecting new tasks and quits), crashes (if a handler is sometimes created on a thread without a Looper active), or race conditions, where the thread a handler is associated with is not what the author anticipated. Instead, use an Executor or specify the Looper explicitly, using Looper#getMainLooper, {link android.view.View#getHandler}, or similar. If the implicit thread local behavior is required for compatibility, use new Handler(Looper.myLooper(), callback) to make it clear to readers.

Solution 1: Use an Executor

1. Execute code in the main thread.

Java

// Create an executor that executes tasks in the main thread. 
Executor mainExecutor = ContextCompat.getMainExecutor(this);

// Execute a task in the main thread
mainExecutor.execute(new Runnable() {
    @Override
    public void run() {
        // You code logic goes here.
    }
});

Kotlin

// Create an executor that executes tasks in the main thread.
val mainExecutor = ContextCompat.getMainExecutor(this)

// Execute a task in the main thread
mainExecutor.execute {
    // You code logic goes here.
}

2. Execute code in a background thread

Java

// Create an executor that executes tasks in a background thread.
ScheduledExecutorService backgroundExecutor = Executors.newSingleThreadScheduledExecutor();

// Execute a task in the background thread.
backgroundExecutor.execute(new Runnable() {
    @Override
    public void run() {
        // Your code logic goes here.
    }
});

// Execute a task in the background thread after 3 seconds.
backgroundExecutor.schedule(new Runnable() {
    @Override
    public void run() {
        // Your code logic goes here
    }
}, 3, TimeUnit.SECONDS);

Kotlin

// Create an executor that executes tasks in a background thread.
val backgroundExecutor: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor()

// Execute a task in the background thread.
backgroundExecutor.execute {
    // Your code logic goes here.
}

// Execute a task in the background thread after 3 seconds.
backgroundExecutor.schedule({
    // Your code logic goes here
}, 3, TimeUnit.SECONDS)

Note: Remember to shut down the executor after using.

backgroundExecutor.shutdown(); // or backgroundExecutor.shutdownNow();

3. Execute code in a background thread and update UI on the main thread.

Java

// Create an executor that executes tasks in the main thread. 
Executor mainExecutor = ContextCompat.getMainExecutor(this);

// Create an executor that executes tasks in a background thread.
ScheduledExecutorService backgroundExecutor = Executors.newSingleThreadScheduledExecutor();

// Execute a task in the background thread.
backgroundExecutor.execute(new Runnable() {
    @Override
    public void run() {
        // Your code logic goes here.
        
        // Update UI on the main thread
        mainExecutor.execute(new Runnable() {
            @Override
            public void run() {
                // You code logic goes here.
            }
        });
    }
});

Kotlin

// Create an executor that executes tasks in the main thread. 
val mainExecutor: Executor = ContextCompat.getMainExecutor(this)

// Create an executor that executes tasks in a background thread.
val backgroundExecutor = Executors.newSingleThreadScheduledExecutor()

// Execute a task in the background thread.
backgroundExecutor.execute {
    // Your code logic goes here.

    // Update UI on the main thread
    mainExecutor.execute {
        // You code logic goes here.
    }
}

Solution 2: Specify a Looper explicitly by using one of the following constructors.

1. Execute code in the main thread

1.1. Handler with a Looper

Java

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

Kotlin

val mainHandler = Handler(Looper.getMainLooper())

1.2 Handler with a Looper and a Handler.Callback

Java

Handler mainHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message message) {
        // Your code logic goes here.
        return true;
    }
});

Kotlin

val mainHandler = Handler(Looper.getMainLooper(), Handler.Callback {
    // Your code logic goes here.
    true
})

2. Execute code in a background thread

2.1. Handler with a Looper

Java

// Create a background thread that has a Looper
HandlerThread handlerThread = new HandlerThread("HandlerThread");
handlerThread.start();

// Create a handler to execute tasks in the background thread.
Handler backgroundHandler = new Handler(handlerThread.getLooper());

Kotlin

// Create a background thread that has a Looper
val handlerThread = HandlerThread("HandlerThread")
handlerThread.start()


// Create a handler to execute tasks in the background thread.
val backgroundHandler = Handler(handlerThread.looper)

2.2. Handler with a Looper and a Handler.Callback

Java

// Create a background thread that has a Looper
HandlerThread handlerThread = new HandlerThread("HandlerThread");
handlerThread.start();

// Create a handler to execute taks in the background thread.
Handler backgroundHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message message) {
        // Your code logic goes here.
        return true;
    }
});

Kotlin

// Create a background thread that has a Looper
val handlerThread = HandlerThread("HandlerThread")
handlerThread.start()


// Create a handler to execute taks in the background thread.
val backgroundHandler = Handler(handlerThread.looper, Handler.Callback {
    // Your code logic goes here.
    true
})

Note: Remember to release the thread after using.

handlerThread.quit(); // or handlerThread.quitSafely();

3. Execute code in a background thread and update UI on the main thread.

Java

// Create a handler to execute code in the main thread
Handler mainHandler = new Handler(Looper.getMainLooper());

// Create a background thread that has a Looper
HandlerThread handlerThread = new HandlerThread("HandlerThread");
handlerThread.start();

// Create a handler to execute in the background thread
Handler backgroundHandler = new Handler(handlerThread.getLooper(), new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message message) {
        // Your code logic goes here.
        
        // Update UI on the main thread.
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                
            }
        });
        
        return true;
    }
});

Kotlin

// Create a handler to execute code in the main thread
val mainHandler = Handler(Looper.getMainLooper())

// Create a background thread that has a Looper
val handlerThread = HandlerThread("HandlerThread")
handlerThread.start()

// Create a handler to execute in the background thread
val backgroundHandler = Handler(handlerThread.looper, Handler.Callback {
    // Your code logic goes here.

    // Update UI on the main thread.
    mainHandler.post {
        
    }
    true
})

Nicolas Jafelle · Answer 3 · 2020-10-02T03:02:19.423

78

If you want to avoid the null check thing in Kotlin (? or !!) you can use Looper.getMainLooper() if your Handler is working with some UI related thing, like this:

Handler(Looper.getMainLooper()).postDelayed({
   Toast.makeText(this@MainActivity, "LOOPER", Toast.LENGTH_SHORT).show()
}, 3000)

Note: use requireContext() instead of this@MainActivity if you are using fragment.

edited Oct 02 '20 at 03:02

answered Jun 19 '20 at 19:56

Nicolas Jafelle

2,661
2
24
30

score 29 · Answer 4 · answered Apr 04 '20 at 07:57

29

The deprecated function is that constructor for Handler. Use Handler(Looper.myLooper()) .postDelayed(runnable, delay) instead

answered Apr 04 '20 at 07:57

Gabe Sechan

90,003
9
87
127

This doesn't work in Kotlin because `Looper.myLooper()` returns a `Looper?` (possible null value). – Ellen Spertus Jun 12 '20 at 17:18
3

@EllenSpertus Then add in a null check, or use Looper.myLooper()!! which will throw an NPE if its null. If you're on a thread with a looper it will return non-null. If not, it will return null and should throw an exception in any language. – Gabe Sechan Jun 12 '20 at 20:23

score 24 · Answer 5 · answered Apr 04 '20 at 06:05

24

Consider using coroutines

scope.launch {
    delay(3000L)
    // do stuff
}

answered Apr 04 '20 at 06:05

Francesc

25,014
10
66
84

15

Inside `Activity` or `Fragment`: `lifecycleScope.launch { delay(3000L) }` – Mahmudul Hasan Shohag Oct 07 '20 at 13:18

Shaon · Answer 6 · 2021-05-09T04:33:51.697

21

Using lifecycle scope this is more easy. Inside activity or fragment.

 lifecycleScope.launch {
     delay(2000)
     // Do your stuff
 }

or use handler

        Handler(Looper.myLooper()!!)

edited May 09 '21 at 04:33

answered Oct 13 '20 at 13:52

Shaon

2,496
26
27

How to avoid the !! operator ? – Jéwôm' Aug 25 '21 at 09:05
It can be null so you have to write !! to ensure it is not null – Shaon Aug 26 '21 at 16:50
1

doing !! can cause exception as looper can be null nad Handler requires a non-nulable value – Bawa Jun 25 '22 at 21:48

score 18 · Answer 7 · edited Mar 31 '22 at 14:22

18

I have 3 solutions:

Specify the Looper explicitly:

Handler(Looper.getMainLooper()).postDelayed({
    // code
}, duration)

Specify the implicit thread local behavior:

Handler(Looper.myLooper()!!).postDelayed({
    // code
}, duration)

using Thread:

Thread({
    try{
        Thread.sleep(3000)
    } catch (e : Exception) {
        throw e
    }
     // code
}).start()

edited Mar 31 '22 at 14:22

damson

2,635
3
21
29

answered Nov 13 '21 at 15:05

Nguyen Thanh Son

641
3
6

score 12 · Answer 8 · answered Jul 23 '21 at 02:30

Handler() and Handler(Handler.Callback callback) constructors are deprecated. Because those can leads to bugs & crashes. Use Executor or Looper explicitly.

For Java

Handler handler = new Handler(Looper.getMainLooper());
handler.postDelayed(new Runnable() {
  @Override
  public void run() {
    //do your work here
   }
}, 1000);

score 10 · Answer 9 · edited Aug 13 '20 at 15:56

10

use this

Looper.myLooper()?.let {
    Handler(it).postDelayed({
        //Your Code
    },2500)
}

edited Aug 13 '20 at 15:56

dStulle

609
5
24

answered Aug 13 '20 at 13:36

Muhammad Nasir Aziz

111
1
6

score 9 · Answer 10 · edited Sep 22 '20 at 06:22

9

Use Executor instead of handler for more info Executor.
To achieve post delay use ScheduledExecutorService:

ScheduledExecutorService worker = Executors.newSingleThreadScheduledExecutor();
Runnable runnable = () -> {
    public void run() {
        // Do something
    }
};
worker.schedule(runnable, 2000, TimeUnit.MILLISECONDS);

edited Sep 22 '20 at 06:22

Martin Zeitler

1
19
155
216

answered Apr 04 '20 at 05:03

ajithvgiri

199
2
5

This is not a bad answer, in fact even [google recommends this](https://developer.android.com/reference/android/os/Handler#Handler()). – iFarbod Sep 03 '20 at 19:49

score 7 · Answer 11 · answered Oct 01 '20 at 13:39

7

Provide a looper in the Handler Constructor

Handler(Looper.getMainLooper())

answered Oct 01 '20 at 13:39

Jeremiah Polo

641
5
10

score 7 · Answer 12 · answered Jan 22 '22 at 06:36

import android.os.Looper
import android.os.Handler

inline fun delay(delay: Long, crossinline completion: () -> Unit) {
    Handler(Looper.getMainLooper()).postDelayed({
        completion()
    }, delay)
}

Example:

delay(1000) {
    view.refreshButton.visibility = View.GONE
}

score 4 · Answer 13 · answered Jan 18 '21 at 13:02

If you are using Variable for Handler and Runnable then use it like this.

private Handler handler;
private Runnable runnable;

handler = new Handler(Looper.getMainLooper());
    handler.postDelayed(runnable = () -> {
        // Do delayed stuff here
         handler.postDelayed(runnable, 1000);
    }, delay);

Also You need to remove callbacks in onDestroy()

@Override
public void onDestroy() {
    super.onDestroy();
    if (handler != null) {
        handler.removeCallbacks(runnable);
    }
}

score 3 · Answer 14 · edited Nov 11 '21 at 02:48

According to the document (https://developer.android.com/reference/android/os/Handler#Handler()):

Implicitly choosing a Looper during Handler construction can lead to bugs where operations are silently lost (if the Handler is not expecting new tasks and quits), crashes (if a handler is sometimes created on a thread without a Looper active), or race conditions, where the thread a handler is associated with is not what the author anticipated. Instead, use an Executor or specify the Looper explicitly, using Looper#getMainLooper, {link android.view.View#getHandler}, or similar. If the implicit thread local behavior is required for compatibility, use new Handler(Looper.myLooper()) to make it clear to readers.

We should stop using the constructor without a Looper, and specify a Looper instead.

score 3 · Answer 15 · answered Apr 03 '21 at 14:12

Coroutines Kotlin

private val SPLASH_SCREEN_TIME_OUT_CONST: Long = 3000

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_splash)
    window.setFlags(
        WindowManager.LayoutParams.FLAG_FULLSCREEN,
        WindowManager.LayoutParams.FLAG_FULLSCREEN
    )
    GlobalScope.launch {
        delay(SPLASH_SCREEN_TIME_OUT_CONST)
        goToIntro()
    }

}

private fun goToIntro(){
    startActivity(Intent(this, IntroActivity::class.java))
    finish()
}

I think there is no difference between GlobalScope vs Handler. The GlobalScope doesn't aware the lifecycle(except the app process). In my opinion, lifecycle scope or custom scope is more convenient way according to the GlobalScope. — Cagdas, Nov 17 '21 at 21:13

score 3 · Answer 16 · answered Apr 28 '21 at 02:11

It's a good idea use this structure in Kotlin

companion object Run {
   fun after(delay: Long, process: () -> Unit) {
      Handler(Looper.getMainLooper()).postDelayed({
          process()
      }, delay)
   }
}

Later call as

Run.after(SPLASH_TIME_OUT) {
   val action = SplashFragmentDirections.actionSplashFragmentToLogin()
   v.findNavController().navigate(action)
}

score 2 · Answer 17 · edited May 21 '21 at 17:55

Java Answer

I wrote a method to use easily. You can use this method directly in your project. delayTimeMillis can be 2000, it means that this code will run after 2 seconds.

private void runJobWithDelay(int delayTimeMillis){
    new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
        @Override
        public void run() {
            //todo: you can call your method what you want.
        }
    }, delayTimeMillis);
}

score 1 · Answer 18 · answered Dec 29 '20 at 17:14

1

I usually use this one

Code:

Handler(Looper.myLooper() ?: return).postDelayed({
           // Code what do you want
        }, 3000)

Screenshot:

answered Dec 29 '20 at 17:14

Abdhi P

79
6

score 0 · Answer 19 · answered Aug 24 '20 at 04:21

The handler() etc code is generated by the Android Studio 4.0.1 when a Fullscreen Activity, for example, is created from scratch. I know that we are being encouraged to use Kotlin, which I do, but from time to time I use sample projects to get an idea going. It seems strange that we are chastised by AS when AS actually generates the code. It might be a useful academic activity to go through the errors and fix them but maybe AS could generate new clean code for us enthusiasts...

score 0 · Answer 20 · answered Jun 06 '22 at 20:53

0

For Xamarin Android, instead of

Handler handler;
handler = new Handler();

just write

Handler handler;
handler = new Handler(Looper.MyLooper());

the rest of the code is fine.

answered Jun 06 '22 at 20:53

stonito

169
1
4

What do I use now that Handler() is deprecated?

20 Answers20

Use it for Java

Use it for Kotlin

Linked

Related