HandlerThread Interaction Example

Question

I want to configure HandlerThread from a GUI thread. Then, after some time, when the button is pressed in the GUI, it launches callHello (), which then sends a message to the HelloLogger object, which is in the stream without the GUI, which asynchronously registers "Hello World". I tried several things, some blocks indefinitely, some never receive a message, etc. Etc. The code below is more or less close to the one I have, please, can someone change it to work?

public class HandlerThreadExample { private MyHandlerThread mMyHandlerThread; private Looper mLooper; private Handler mHandler; public HandlerThreadExample(){ mMyHandlerThread = new MyHandlerThread(); mMyHandlerThread.start(); mLooper = mMyHandlerThread.getLooper(); } public void callHello() { mHandler.sendEmptyMessage(1); } private class MyHandlerThread extends HandlerThread { private HelloLogger mHelloLogger; private Handler mHandler; public MyHandlerThread() { super("The MyHandlerThread thread", HandlerThread.NORM_PRIORITY); } public void run (){ mHelloLogger = new HelloLogger(); mHandler = new Handler(getLooper()){ public void handleMessage(Message msg){ mHelloLogger.logHello(); } }; super.run(); } } private class HelloLogger { public HelloLogger (){ } public void logHello(){ Log.d("HandlerThreadExample", "Hello World"); } } } 

Found examples:

• HandlerThread Test
• How to create a Looper stream and then send its message right away?
• Asynchronous calls with a handler
• HandlerThread vs Executor - When is another approach to another?
• Better use of HandlerThread over other similar classes
• Android HandlerThread
• HandlerThread Examples
• Android: transferring data between main and worker threads
• Java synchronized
• Sending messages between threads using the workflow queue and the Handler class
• Joining Loopers and Handlers
• developer.android: specifying code to run in a thread

At least now I can close the damn tabs

Solution provided by pskink

 public class HandlerThreadExample2 { private static int MSG_START_HELLO = 0; private static int MSG_HELLO_COMPLETE = 1; private HandlerThread ht; private Handler mHtHandler; private Handler mUiHandler; private boolean helloReady = false; public HandlerThreadExample2(){ ht = new HandlerThread("The new thread"); ht.start(); Log.d(App.TAG, "UI: handler thread started"); mUiHandler = new Handler(){ public void handleMessage(Message msg){ if (msg.what == MSG_HELLO_COMPLETE){ Log.d(App.TAG, "UI Thread: received notification of sleep completed "); helloReady = true; } } }; mHtHandler = new Handler(ht.getLooper()){ public void handleMessage (Message msg){ if (msg.what == MSG_START_HELLO){ Log.d(App.TAG, "handleMessage " + msg.what + " in " + Thread.currentThread() + " now sleeping"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } Log.d(App.TAG, "Woke up, notifying UI thread..."); mUiHandler.sendEmptyMessage(MSG_HELLO_COMPLETE); } } }; } public void sendLongHello(){ if (helloReady){ Log.d(App.TAG, "sending hello " + Thread.currentThread()); mHtHandler.sendEmptyMessage(MSG_START_HELLO); helloReady = false; } else { Log.e(App.TAG, "Cannot do hello yet - not ready"); } } } 

Answer 1

This is a working example:

 HandlerThread ht = new HandlerThread("MySuperAwesomeHandlerThread"); ht.start(); Handler h = new Handler(ht.getLooper()) { public void handleMessage(Message msg) { Log.d(TAG, "handleMessage " + msg.what + " in " + Thread.currentThread()); }; }; for (int i = 0; i < 5; i++) { Log.d(TAG, "sending " + i + " in " + Thread.currentThread()); h.sendEmptyMessageDelayed(i, 3000 + i * 1000); } 

UPDATE

Make two class fields:

 Handler mHtHandler; Handler mUiHandler; 

and try the following:

 HandlerThread ht = new HandlerThread("MySuperAwsomeHandlerThread"); ht.start(); Callback callback = new Callback() { @Override public boolean handleMessage(Message msg) { if (msg.what == 0) { Log.d(TAG, "got a meaasage in " + Thread.currentThread() + ", now sleeping... "); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } Log.d(TAG, "woke up, notifying ui thread..."); mUiHandler.sendEmptyMessage(1); } else if (msg.what == 1) { Log.d(TAG, "got a notification in " + Thread.currentThread()); } return false; } }; mHtHandler = new Handler(ht.getLooper(), callback); mUiHandler = new Handler(callback); mHtHandler.sendEmptyMessageDelayed(0, 3000); 

You can, of course, get rid of the Callback interface and create two handlers with an overridden handleMessage method ...

Answer 2

The problem you see is that your outer class uses the mHandler private field as well as your HandlerThread. The outer class field is not initialized. You do not need an internal mHandler. The outer class can break the handler from the looper, which you capture immediately after calling start ().