AndroidでのLooper,MessageとHandleの簡単な関係の説明

Looper:1つのスレッドには1つのLooperインスタンスしか存在しません.Activityが作成されると、システムは自動的に1つを作成し、MessageQueueを生成します.期間中に主に使用される方法はprepare()とloop()です.prepare():MessageQueueを管理するためにLooperオブジェクトを生成し、1つのLooperオブジェクトに1つのMessageQueueしか存在しません.loop():MessageQueueからメッセージをループして取り出します.1.Activity Threadのmain()メソッド:

    public static void main(String[] args) {  
        SamplingProfilerIntegration.start();  
        CloseGuard.setEnabled(false);  
        Environment.initForCurrentUser();  
        EventLogger.setReporter(new EventLoggingReporter());  
        Process.setArgV0("");  
        Looper.prepareMainLooper();  
        ActivityThread thread = new ActivityThread();  
        thread.attach(false);  
        if (sMainThreadHandler == null) {  
            sMainThreadHandler = thread.getHandler();  
        }  
        AsyncTask.init();  
        if (false) {  
            Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread"));  
        }  
        Looper.loop();  
        throw new RuntimeException("Main thread loop unexpectedly exited");  
    }  

2.Looper.prepare()メソッド:Looper.prepareMainLooper()はLooperを呼び出します.prepare()メソッド、コードは次のとおりです.

    public static final void prepareMainLooper() {  
        prepare();  
        setMainLooper(myLooper());  
        if (Process.supportsProcesses()) {  
            myLooper().mQueue.mQuitAllowed = false;  
        }  
    }  

以上のコードはシステムによって自動的に実現され、UIスレッドにはこのLooperオブジェクトとMessageQueueがずっと存在します.2.loop()メソッド:

    public static void loop() {  
            final Looper me = myLooper();  
            if (me == null) {  
                throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");  
            }  
            final MessageQueue queue = me.mQueue;  

            // Make sure the identity of this thread is that of the local process,  
            // and keep track of what that identity token actually is.  
            Binder.clearCallingIdentity();  
            final long ident = Binder.clearCallingIdentity();  

            for (;;) {  
                Message msg = queue.next(); // might block  
                if (msg == null) {  
                    // No message indicates that the message queue is quitting.  
                    return;  
                }  

                // This must be in a local variable, in case a UI event sets the logger  
                Printer logging = me.mLogging;  
                if (logging != null) {  
                    logging.println(">>>>> Dispatching to " + msg.target + " " +  
                            msg.callback + ": " + msg.what);  
                }  

                msg.target.dispatchMessage(msg);  

                if (logging != null) {  
                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);  
                }  

                // Make sure that during the course of dispatching the  
                // identity of the thread wasn't corrupted.  
                final long newIdent = Binder.clearCallingIdentity();  
                if (ident != newIdent) {  
                    Log.wtf(TAG, "Thread identity changed from 0x"  
                            + Long.toHexString(ident) + " to 0x"  
                            + Long.toHexString(newIdent) + " while dispatching to "  
                            + msg.target.getClass().getName() + " "  
                            + msg.callback + " what=" + msg.what);  
                }  

                msg.recycle();  
            }  
    }  

loop()メソッドは,MessageQueueからメッセージを取り出し,メッセージのtarget属性のdispatchMessageに渡して処理する.
Handler:Handlerインスタンスによって、サブスレッドでMessageQueueにメッセージが送信され、UIスレッドでコールバックによってメッセージが受信される.1.現在のMessageQueueにバインドします.

    public Handler() {  
            this(null, false);  
    }  
    public Handler(Callback callback, boolean async) {  
            if (FIND_POTENTIAL_LEAKS) {  
                final Class extends Handler> klass = getClass();  
                if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
                        (klass.getModifiers() & Modifier.STATIC) == 0) {  
                    Log.w(TAG, "The following Handler class should be static or leaks might occur: " +  
                        klass.getCanonicalName());  
                }  
            }  

            mLooper = Looper.myLooper();  
            if (mLooper == null) {  
                throw new RuntimeException(  
                    "Can't create handler inside thread that has not called Looper.prepare()");  
            }  
            mQueue = mLooper.mQueue;  
            mCallback = callback;  
            mAsynchronous = async;  
        }  

//sendMessage:

public final boolean sendMessage(Message msg)  
     {  
         return sendMessageDelayed(msg, 0);  
     }

//sendEmptyMessageDelayed:

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {  
         Message msg = Message.obtain();  
         msg.what = what;  
         return sendMessageDelayed(msg, delayMillis);  
     }  

//sendMessageDelayed:

    public final boolean sendMessageDelayed(Message msg, long delayMillis)  
       {  
           if (delayMillis < 0) {  
               delayMillis = 0;  
           }  
           return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
       }  

//sendMessageAtTime:

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {  
           MessageQueue queue = mQueue;  
           if (queue == null) {  
               RuntimeException e = new RuntimeException(  
                       this + " sendMessageAtTime() called with no mQueue");  
               Log.w("Looper", e.getMessage(), e);  
               return false;  
           }  
           return enqueueMessage(queue, msg, uptimeMillis);  
       }  

//enqueueMessage:

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
       msg.target = this;  
       if (mAsynchronous) {  
           msg.setAsynchronous(true);  
       }  
       return queue.enqueueMessage(msg, uptimeMillis);  
   } 

最後にenqueueMessageというメソッドが呼び出され、enqueueMessageではまずthisをmegに付与する.targetは、現在のhandlerをmsgのtarget属性として、最後にqueueを呼び出す.EnqueueMessageは、現在のmsg(handler)をメッセージキューに追加します.loopメソッドは各msgを取り出してmsg,targetに渡す.dispatchMessage(msg)はメッセージを処理する.

    public void dispatchMessage(Message msg) {  
            if (msg.callback != null) {  
                handleCallback(msg);  
            } else {  
                if (mCallback != null) {  
                    if (mCallback.handleMessage(msg)) {  
                        return;  
                    }  
                }  
                handleMessage(msg);  
            }  
        }  

最終的には、UIスレッドで受信したメッセージを処理することができます.

    private Handler mHandler = new Handler()  
        {  
            public void handleMessage(android.os.Message msg)  
            {  
                switch (msg.what)  
                {  
                case value:  

                    break;  

                default:  
                    break;  
                }  
            };  
        };  

これでプロセス全体がほぼ終わります.考えを整理します:1、Looper.prepare()は、Looperインスタンスを生成し、MessageQueueオブジェクトを保存します.2、Looper.loop()は、現在のスレッドを無限ループにし、MessageQueueからメッセージを読み出し、msgをコールバックする.target.dispatchMessage(msg)法.3.Handlerの構築方法は、まず現在のスレッドに保存されているLooperインスタンスを取得し、さらにLooperインスタンスのMessageQueueに関連付ける.4、HandlerのsendMessageメソッドは、msgのtargetにhandler自身に割り当てられ、MessageQueueに追加されます.5.Handlerインスタンスを構築する際、handleMessageメソッド、すなわちmsgを書き換える.target.dispatchMessage(msg)が最終的に呼び出す方法.「Android非同期メッセージ処理メカニズムを参考にLooper、Handler、Messageの3つの関係を深く理解させ、Android非同期メッセージ処理メカニズムを完全に解析し、ソースコードの観点から徹底的に理解させる」