HandlerThread

HandlerThread is a thread with a message queue that incorporates a Thread, a Looper, and a MessageQueue.

HandlerThread handlerThread = new HandlerThread(“HandlerThread”);

handlerThread.start();

mHandler = new Handler(handlerThread.getLooper()) {

@Override

public void handleMessage(Message msg) { super.handleMessage(msg);

// Process messages here

}

};

Creation: The constructor for HandlerThread takes a mandatory name argument and an optional priority for the thread:

**HandlerThread(String name)

HandlerThread(String name, int priority)**

The default priority is Pro cess.THREAD_PRIORITY_DEFAULT—the same priority as the UI thread—and can be lowered to Process.THREAD_PRIORITY_BACKGROUND to execute noncritical tasks

Execution:A HandlerThread is always ready to receive messages when the Handler can be created, as getLooper blocks until the Looper is prepared

Reset:The message queue can be reset so that no more of the queued messages will be processed, but the thread remains alive and can process new messages. The reset will remove all pending messages in the queue, but not affect a message that has been dispatched and is executing on the thread:

**public void resetHandlerThread() {

mHandler.removeCallbacksAndMessages(null);

}**

Termination: A HandlerThread is terminated either with quit or quitSafely.With quit, no further messages will be dispatched to the HandlerThread, whereas quitSafely ensures that messages that have passed the dispatch barrier are processed before the thread is terminated

You can also send an interrupt to the HandlerThread to cancel the currently executing message:

**public void stopHandlerThread(HandlerThread handlerThread) {

handlerThread.quit();

handlerThread.interrupt();

}**

A HandlerThread can also be terminated by sending a finalization task to the Han dler that quits the Looper, and consequently the HandlerThread:

**handler.post(new Runnable() {

@Override

public void run() {

Looper.myLooper().quit();

}

});**

The finalization task ensures that this will be the last executed task on this thread, once it has been dispatched by the Looper. There is, however, no guarantee that other tasks will not move ahead of the finalization task by being posted to the front of the queue through Handler.postAtFrontOfQueue

public class SharedPreferencesActivity extends Activity {
TextView mTextValue;
//Show read value in a TextView.
private Handler mUiHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what == 0) {
Integer i = (Integer)msg.obj;
mTextValue.setText(Integer.toString(i));
}
}
};

private class SharedPreferenceThread extends HandlerThread {
private static final String KEY = "key";
private static final int READ = 1;
private static final int WRITE = 2;
private Handler mHandler;

public SharedPreferenceThread() {
super("SharedPreferenceThread", Process.THREAD_PRIORITY_BACKGROUND);
mPrefs = getSharedPreferences("LocalPrefs", MODE_PRIVATE);
}

@Override
protected void onLooperPrepared() {
super.onLooperPrepared();
mHandler = new Handler(getLooper()) {
@Override
public void handleMessage(Message msg) {
switch(msg.what) {
case READ:
mUiHandler.sendMessage(mUiHandler.obtainMessage(0,mPrefs.getInt(KEY,
0)));
break;
case WRITE:
SharedPreferences.Editor editor = mPrefs.edit();
editor.putInt(KEY, (Integer)msg.obj);
editor.commit();
break;
}
}
};
}

public void read() {
mHandler.sendEmptyMessage(READ);
}

public void write(int i) {
mHandler.sendMessage(Message.obtain(Message.obtain(mHandler,WRITE, i)));
}
}

private int mCount;
private SharedPreferenceThread mThread;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mTextValue = (TextView) findViewById(R.id.text_value);
mThread = new SharedPreferenceThread(); mThread.start();
}

//Write dummy value from the UI thread.

public void onButtonClickWrite(View v) {
mThread.write(mCount++);
}

//Initiate a read from the UI thread.

public void onButtonClickRead(View v) {
mThread.read();
}

//Ensure that the background thread is terminated with the Activity.

@Override
protected void onDestroy() {
super.onDestroy();
mThread.quit();
}
}

public class ChainedNetworkActivity extends Activity {
private static final int DIALOG_LOADING = 0;
private static final int SHOW_LOADING = 1;
private static final int DISMISS_LOADING = 2;
Handler dialogHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case SHOW_LOADING:
showDialog(DIALOG_LOADING);
break;
case DISMISS_LOADING:
dismissDialog(DIALOG_LOADING);
}
}
};

private class NetworkHandlerThread extends HandlerThread {
private static final int STATE_A = 1;

beac
private static final int STATE_B = 2;
private Handler mHandler;
public NetworkHandlerThread() {
super("NetworkHandlerThread", Process.THREAD_PRIORITY_BACKGROUND);
}

@Override
protected void onLooperPrepared() {
super.onLooperPrepared();
mHandler = new Handler(getLooper()) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case STATE_A:
dialogHandler.sendEmptyMessage(SHOW_LOADING);
String result = networkOperation1();
if (result != null) {
sendMessage(obtainMessage(STATE_B, result));
} else {
dialogHandler.sendEmptyMessage(DISMISS_LOADING);
}
break;
case STATE_B:
networkOperation2((String) msg.obj);
dialogHandler.sendEmptyMessage(DISMISS_LOADING);
break;
}
}
};
fetchDataFromNetwork();
}

private String networkOperation1() {
SystemClock.sleep(2000); // Dummy
}

private void networkOperation2(String data) {
// Pass data to network, e.g. with HttpPost.
SystemClock.sleep(2000); // Dummy
}

// Publically exposed network operation
public void fetchDataFromNetwork() {
mHandler.sendEmptyMessage(STATE_A);
}
}

private NetworkHandlerThread mThread;

public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mThread = new NetworkHandlerThread(); mThread.start();
}

@Override
protected Dialog onCreateDialog(int id) {
Dialog dialog = null;
switch (id) {
case DIALOG_LOADING:
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setMessage("Loading...");
dialog = builder.create();
break;
}
return dialog;
}

//Ensure that the background thread is terminated with the Activity.
@Override
protected void onDestroy() {
super.onDestroy();
mThread.quit();
}
}