Talking about Android Message Queue

Talking about Android Message Queue

Android does not implement a global message queue to allow cross-process communication through message like Windows. Actually if you need cross-process communication, the official method in Android is intent. Android only supports in-process communication through message.

I wonder in the feature Android will add supporting cross-process message, because you can see some code snippet(片段) for IMessager in Messager.java and Handler.java. But you have no way to get an instance of IBinder proxy（代理人） object for IMessager.

Looper.java is the class used to run a MessageQueue for a thread. Threads by default do not have a MessageQueue associated with them. To create one, the following code shows a typical example of the implementation of a Looper thread and an initial Handler to communication with the Looper. One thread can have only one Looper instance.

// Example 1:

class LooperThread extends Thread {

    public Handler mHandler;

    public void run() {

        Looper.prepare();

        mHandler = new Handler() {

            public void handleMessage(Message msg) {

                // process incoming messages here

            }

        };

        Looper.loop();

    }

}

When a process is created for your JAVA application, its main thread is dedicated to running a message queue that takes care of managing the top-level application objects (activities, intent receivers, etc) and any windows they create, so that you don’t need to create a Looper object for the main thread. Here shows the code snippets in ActivityThread.java which creates the Looper object for the main thread.

    public static final void main(String[] args) {

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();

        thread.attach(false);

        Looper.loop();

        if (Process.supportsProcesses()) {

            throw new RuntimeException("Main thread loop unexpectedly exited");

        }

        thread.detach();

    }

Handler.java allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue. Each Handler instance is associated with a single thread. When you create a new Handler, it is bound to the thread that is creating it – from that point on, it will deliver messages and runnables to that thread’s message queue and execute them as they come out of the message queue.

Scheduling message APIs in Handler can be divided into two types: send and post. The send versions allow you to enqueue a Message object containing a bundle of data that will be processed by the Handler’s handleMessage method (requiring that you implement a subclass of Handler). Please refer to the previous Example 1 as an example. The post versions allow you to enqueue a Runnable object to be called by the message queue when it is received. The following code snippets show an example.

// Example 2:

class MyActivity extends Activity {

    Handler mHandler = new Handler();

    public void XXX() {

        // post a runnable object to run on main message queue

mHandler.post(new Runnable() {

            public void run() {

                // now it’s run on the thread corresponding to mHandler.

            }

        });

    }

}