android Messenger 跨进程通讯

 Messenger:信使
官方文档解释：它引用了一个Handler对象，以便others能够向它发送消息(使用mMessenger.send(Message msg)方法)。该类允许跨进程间基于Message的通信(即两个进程间可以通过Message进行通信)，在服务端使用Handler创建一个Messenger，客户端持有这个Messenger就可以与服务端通信了。

以前我们使用Handler+Message的方式进行通信，都是在同一个进程中，从线程持有一个主线程的Handler对象，并向主线程发送消息。
而Android既然可以使用bindler机制进行跨进行通信，所以我们当然可以将Handler与bindler结合起来进行跨进程发送消息。
查看API就可以发现，Messenger就是这种方式的实现。
一般使用方法如下：
１。远程通过

Java代码  

1. mMessenger = new Messenger(mHandler)   

mMessenger = new Messenger(mHandler) 

创建一个信使对象
２。客户端使用bindlerService请求连接远程
３。远程onBind方法返回一个bindler

Java代码  

1. return mMessenger.getBinder();   

return mMessenger.getBinder(); 

4.客户端使用远程返回的bindler得到一个信使（即得到远程信使）
 

Java代码  

1. public void onServiceConnected(ComponentName name, IBinder service) {     
2.     rMessenger = new Messenger(service);     
3. 　　　　　......     
4. }  

public void onServiceConnected(ComponentName name, IBinder service) {  
    rMessenger = new Messenger(service);  
　　　　　......  
}

 
这里虽然是new了一个Messenger，但我们查看它的实现
 

Java代码  

1. /**   
2.  * Create a Messenger from a raw IBinder, which had previously been   
3.  * retrieved with {@link #getBinder}.   
4.  *    
5.  * @param target The IBinder this Messenger should communicate with.   
6.  */     
7. public Messenger(IBinder target) {     
8.     mTarget = IMessenger.Stub.asInterface(target);     
9. }    

/** 
 * Create a Messenger from a raw IBinder, which had previously been 
 * retrieved with {@link #getBinder}. 
 *  
 * @param target The IBinder this Messenger should communicate with. 
 */  
public Messenger(IBinder target) {  
    mTarget = IMessenger.Stub.asInterface(target);  
}  

发现它的mTarget是通过Aidl得到的，实际上就是远程创建的那个。
５。客户端可以使用这个远程信使对象向远程发送消息：

Java代码  

1. rMessenger.send(msg);  

rMessenger.send(msg);

这样远程服务端的Handler对象就能收到消息了，然后可以在其
handlerMessage(Message msg)方法中进行处理。（该Handler对象就是第一步服务端创建Messenger时使用的参数mHandler）.

经过这５个步骤貌似只有客户端向服务端发送消息，这样的消息传递是单向的，那么如何实现双向传递呢？
首先需要在第５步稍加修改，在send(msg)前通过msm.replyTo = mMessenger将自己的信使设置到消息中，这样服务端接收到消息时同时也得到了客户端的信使对象了，然后服务端可以通过

Java代码  

1. //得到客户端的信使对象，并向它发送消息     
2. cMessenger = msg.replyTo;     
3. cMessenger.send(message);   

//得到客户端的信使对象，并向它发送消息  
cMessenger = msg.replyTo;  
cMessenger.send(message); 

即完成了从服务端向客户端发送消息的功能，这样客服端可以在自己的Handler对象的handlerMessage方法中接收服务端发送来的message进行处理。
双向通信宣告完成。

下面改写ApiDemos工程实现Messenger通信
MessengerService.java

Java代码  

1.      
2. package com.xwangly.apidemo.app;     
3.      
4. import java.util.Random;     
5.      
6. import android.app.Service;     
7. import android.content.Intent;     
8. import android.os.Handler;     
9. import android.os.IBinder;     
10. import android.os.Message;     
11. import android.os.Messenger;     
12. import android.os.RemoteException;     
13. import android.util.Log;     
14.      
15. public class MessengerService extends Service {     
16.     private String TAG = "MessengerService";     
17.      
18.     @Override     
19.     public void onDestroy() {     
20.         // TODO Auto-generated method stub     
21.         Log.i(TAG, "onDestroy");     
22.         cMessenger = null;     
23.         super.onDestroy();     
24.     }     
25.      
26.     @Override     
27.     public boolean onUnbind(Intent intent) {     
28.         // TODO Auto-generated method stub     
29.         Log.i(TAG, "onUnbind");     
30.         return super.onUnbind(intent);     
31.     }     
32.      
33.     static final int MSG_REGISTER_CLIENT = 1;     
34.     static final int MSG_UNREGISTER_CLIENT = 2;     
35.     static final int MSG_SET_VALUE = 3;     
36.      
37.     private Random random = new Random();     
38.      
39.     private Handler mHandler = new Handler() {     
40.      
41.         @Override     
42.         public void handleMessage(Message msg) {     
43.             // TODO Auto-generated method stub     
44.             Log.i(TAG, "handleMessage");     
45.             switch (msg.what) {     
46.             case MSG_SET_VALUE:     
47.                 try {     
48.                     Message message = Message.obtain(null,     
49.                             MessengerService.MSG_SET_VALUE);     
50.                     message.arg1 = random.nextInt(100);     
51.                          
52.                     //得到客户端的信使对象，并向它发送消息     
53.                     cMessenger = msg.replyTo;     
54.                     cMessenger.send(message);     
55.                 } catch (RemoteException e) {     
56.                     // TODO Auto-generated catch block     
57.                     e.printStackTrace();     
58.                 }     
59.                 break;     
60.             default:     
61.                 super.handleMessage(msg);     
62.             }     
63.      
64.         }     
65.     };     
66.      
67.     /**   
68.      * 自己的信使对象   
69.      */     
70.     private Messenger mMessenger = new Messenger(mHandler);     
71.      
72.     /**   
73.      * 客户的信使   
74.      */     
75.     private Messenger cMessenger;     
76.      
77.     @Override     
78.     public IBinder onBind(Intent intent) {     
79.         // TODO Auto-generated method stub     
80.         Log.i(TAG, "onBind");     
81.         //返回自己信使的bindler,以供客户端通过这个bindler得到服务端的信使对象（通过new Messenger(bindler)）     
82.         return mMessenger.getBinder();     
83.     }     
84.      
85.     @Override     
86.     public void onRebind(Intent intent) {     
87.         // TODO Auto-generated method stub     
88.         Log.i(TAG, "onRebind");     
89.      
90.     }     
91.      
92. }   

  
package com.xwangly.apidemo.app;  
  
import java.util.Random;  
  
import android.app.Service;  
import android.content.Intent;  
import android.os.Handler;  
import android.os.IBinder;  
import android.os.Message;  
import android.os.Messenger;  
import android.os.RemoteException;  
import android.util.Log;  
  
public class MessengerService extends Service {  
    private String TAG = "MessengerService";  
  
    @Override  
    public void onDestroy() {  
        // TODO Auto-generated method stub  
        Log.i(TAG, "onDestroy");  
        cMessenger = null;  
        super.onDestroy();  
    }  
  
    @Override  
    public boolean onUnbind(Intent intent) {  
        // TODO Auto-generated method stub  
        Log.i(TAG, "onUnbind");  
        return super.onUnbind(intent);  
    }  
  
    static final int MSG_REGISTER_CLIENT = 1;  
    static final int MSG_UNREGISTER_CLIENT = 2;  
    static final int MSG_SET_VALUE = 3;  
  
    private Random random = new Random();  
  
    private Handler mHandler = new Handler() {  
  
        @Override  
        public void handleMessage(Message msg) {  
            // TODO Auto-generated method stub  
            Log.i(TAG, "handleMessage");  
            switch (msg.what) {  
            case MSG_SET_VALUE:  
                try {  
                    Message message = Message.obtain(null,  
                            MessengerService.MSG_SET_VALUE);  
                    message.arg1 = random.nextInt(100);  
                      
                    //得到客户端的信使对象，并向它发送消息  
                    cMessenger = msg.replyTo;  
                    cMessenger.send(message);  
                } catch (RemoteException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                break;  
            default:  
                super.handleMessage(msg);  
            }  
  
        }  
    };  
  
    /** 
     * 自己的信使对象 
     */  
    private Messenger mMessenger = new Messenger(mHandler);  
  
    /** 
     * 客户的信使 
     */  
    private Messenger cMessenger;  
  
    @Override  
    public IBinder onBind(Intent intent) {  
        // TODO Auto-generated method stub  
        Log.i(TAG, "onBind");  
        //返回自己信使的bindler,以供客户端通过这个bindler得到服务端的信使对象（通过new Messenger(bindler)）  
        return mMessenger.getBinder();  
    }  
  
    @Override  
    public void onRebind(Intent intent) {  
        // TODO Auto-generated method stub  
        Log.i(TAG, "onRebind");  
  
    }  
  
} 

MessengerServiceActivities.java

Java代码  

1.     
2. package com.xwangly.apidemo.app;     
3.      
4. import com.xwangly.apidemo.R;     
5.      
6. import android.app.Activity;     
7. import android.content.ComponentName;     
8. import android.content.Intent;     
9. import android.content.ServiceConnection;     
10. import android.os.Bundle;     
11. import android.os.Handler;     
12. import android.os.IBinder;     
13. import android.os.Message;     
14. import android.os.Messenger;     
15. import android.os.RemoteException;     
16. import android.util.Log;     
17. import android.view.View;     
18. import android.widget.TextView;     
19.      
20. public class MessengerServiceActivities {     
21.     public static class Binding extends Activity implements     
22.             View.OnClickListener {     
23.         private String TAG = "Binding";     
24.      
25.         TextView mCallbackText;     
26.      
27.         private boolean isBound;     
28.      
29.         @Override     
30.         protected void onCreate(Bundle savedInstanceState) {     
31.             // TODO Auto-generated method stub     
32.             super.onCreate(savedInstanceState);     
33.             setContentView(R.layout.messenger_service_binding);     
34.             findViewById(R.id.bind).setOnClickListener(this);     
35.             findViewById(R.id.unbind).setOnClickListener(this);     
36.      
37.             mCallbackText = (TextView) findViewById(R.id.callback);     
38.             mCallbackText.setText("Not attached.");     
39.      
40.         }     
41.      
42.         private Handler mHandler = new Handler() {     
43.             @Override     
44.             public void handleMessage(Message msg) {     
45.                 Log.i(TAG, "handleMessage");     
46.                 switch (msg.what) {     
47.                 case MessengerService.MSG_SET_VALUE:     
48.                     mCallbackText.setText("Received from service: " + msg.arg1);     
49.                     break;     
50.                 default:     
51.                     super.handleMessage(msg);     
52.                 }     
53.             }     
54.         };     
55.      
56.         /**   
57.          * 自己的信使   
58.          */     
59.         private Messenger mMessenger;     
60.              
61.         /**   
62.          * 远程服务的信使   
63.          */     
64.         private Messenger rMessenger;     
65.              
66.         private ServiceConnection connection = new ServiceConnection() {     
67.      
68.             public void onServiceConnected(ComponentName name, IBinder service) {     
69.                 // TODO Auto-generated method stub     
70.                 Log.i(TAG, "onServiceConnected");     
71.                 rMessenger = new Messenger(service);     
72.                 mMessenger = new Messenger(mHandler);     
73.                      
74.                 sendMessage();     
75.             }     
76.      
77.      
78.             public void onServiceDisconnected(ComponentName name) {     
79.                 // TODO Auto-generated method stub     
80.                 rMessenger = null;     
81.             }     
82.         };     
83.      
84.         public void onClick(View v) {     
85.             // TODO Auto-generated method stub     
86.             Intent intent = new Intent(     
87.                     "com.xwangly.apidemo.app.messenger_service");     
88.             switch (v.getId()) {     
89.             case R.id.bind:     
90.                 if (!isBound) {     
91.                     isBound = bindService(intent, connection, BIND_AUTO_CREATE);     
92.                     //isBound = true;     
93.                 }else {     
94.                     sendMessage();     
95.                 }     
96.                 break;     
97.             case R.id.unbind:     
98.                 if (isBound) {     
99.                     unbindService(connection);     
100.                     isBound = false;     
101.                 }     
102.                 break;     
103.             default:     
104.                 break;     
105.             }     
106.         }     
107.              
108.         /**   
109.          * 使用服务端的信使向它发送一个消息。   
110.          */     
111.         private void sendMessage() {     
112.             // TODO Auto-generated method stub     
113.             Message message = Message.obtain(null, MessengerService.MSG_SET_VALUE);     
114.             message.replyTo = mMessenger;     
115.             try {     
116.                 rMessenger.send(message);     
117.             } catch (RemoteException e) {     
118.                 // TODO Auto-generated catch block     
119.                 e.printStackTrace();     
120.             }     
121.         }     
122.      
123.     }     
124.      
125. }   

 
package com.xwangly.apidemo.app;  
  
import com.xwangly.apidemo.R;  
  
import android.app.Activity;  
import android.content.ComponentName;  
import android.content.Intent;  
import android.content.ServiceConnection;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.IBinder;  
import android.os.Message;  
import android.os.Messenger;  
import android.os.RemoteException;  
import android.util.Log;  
import android.view.View;  
import android.widget.TextView;  
  
public class MessengerServiceActivities {  
    public static class Binding extends Activity implements  
            View.OnClickListener {  
        private String TAG = "Binding";  
  
        TextView mCallbackText;  
  
        private boolean isBound;  
  
        @Override  
        protected void onCreate(Bundle savedInstanceState) {  
            // TODO Auto-generated method stub  
            super.onCreate(savedInstanceState);  
            setContentView(R.layout.messenger_service_binding);  
            findViewById(R.id.bind).setOnClickListener(this);  
            findViewById(R.id.unbind).setOnClickListener(this);  
  
            mCallbackText = (TextView) findViewById(R.id.callback);  
            mCallbackText.setText("Not attached.");  
  
        }  
  
        private Handler mHandler = new Handler() {  
            @Override  
            public void handleMessage(Message msg) {  
                Log.i(TAG, "handleMessage");  
                switch (msg.what) {  
                case MessengerService.MSG_SET_VALUE:  
                    mCallbackText.setText("Received from service: " + msg.arg1);  
                    break;  
                default:  
                    super.handleMessage(msg);  
                }  
            }  
        };  
  
        /** 
         * 自己的信使 
         */  
        private Messenger mMessenger;  
          
        /** 
         * 远程服务的信使 
         */  
        private Messenger rMessenger;  
          
        private ServiceConnection connection = new ServiceConnection() {  
  
            public void onServiceConnected(ComponentName name, IBinder service) {  
                // TODO Auto-generated method stub  
                Log.i(TAG, "onServiceConnected");  
                rMessenger = new Messenger(service);  
                mMessenger = new Messenger(mHandler);  
                  
                sendMessage();  
            }  
  
  
            public void onServiceDisconnected(ComponentName name) {  
                // TODO Auto-generated method stub  
                rMessenger = null;  
            }  
        };  
  
        public void onClick(View v) {  
            // TODO Auto-generated method stub  
            Intent intent = new Intent(  
                    "com.xwangly.apidemo.app.messenger_service");  
            switch (v.getId()) {  
            case R.id.bind:  
                if (!isBound) {  
                    isBound = bindService(intent, connection, BIND_AUTO_CREATE);  
                    //isBound = true;  
                }else {  
                    sendMessage();  
                }  
                break;  
            case R.id.unbind:  
                if (isBound) {  
                    unbindService(connection);  
                    isBound = false;  
                }  
                break;  
            default:  
                break;  
            }  
        }  
          
        /** 
         * 使用服务端的信使向它发送一个消息。 
         */  
        private void sendMessage() {  
            // TODO Auto-generated method stub  
            Message message = Message.obtain(null, MessengerService.MSG_SET_VALUE);  
            message.replyTo = mMessenger;  
            try {  
                rMessenger.send(message);  
            } catch (RemoteException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
  
    }  
  
} 

AndroidManifest.xml相关配置如下：

Java代码  

1.      
2. <service android:name=".app.MessengerService" >     
3.     <intent-filter>     
4.         <action android:name="com.xwangly.apidemo.app.messenger_service" />     
5.     </intent-filter>     
6. </service>     
7.       <activity android:name=".app.MessengerServiceActivities$Binding"     
8.               android:label="@string/activity_messenger_service_binding"     
9.               android:launchMode="singleTop">     
10.           <intent-filter>     
11.               <action android:name="android.intent.action.MAIN" />     
12.               <category android:name="android.intent.category.LAUNCHER" />     
13.           </intent-filter>     
14.       </activity>    

  
<service android:name=".app.MessengerService" >  
    <intent-filter>  
        <action android:name="com.xwangly.apidemo.app.messenger_service" />  
    </intent-filter>  
</service>  
      <activity android:name=".app.MessengerServiceActivities$Binding"  
              android:label="@string/activity_messenger_service_binding"  
              android:launchMode="singleTop">  
          <intent-filter>  
              <action android:name="android.intent.action.MAIN" />  
              <category android:name="android.intent.category.LAUNCHER" />  
          </intent-filter>  
      </activity>  

至于layout就不帖了，两个按钮一个文本域。