android IPC机制之Messenger

1. Messenger是什么？

   Messenger译为：信使。通过它可以在不同的进程中传递Message对象，在Message中放入我们需要传递的数据，就可以实现数据的进程间传递。
   Messenger是一种轻量级的IPC,它的底层实现是AIDL。AIDL详细使用看这里

      /**
        * Create a new Messenger pointing to the given Handler.  Any Message
        * objects sent through this Messenger will appear in the Handler as if
        * {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
        * been called directly.
        * 
        * @param target The Handler that will receive sent messages.
        */
       public Messenger(Handler target) {
           mTarget = target.getIMessenger();
       }
   
    /**
        * 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);
       }
   
   

   从IMessenger.Stub.asInterface(target);明显看出底层使用了AIDL的痕迹。

2. Messenger的使用

   1. 服务端：

       public class MessengerService extends Service {
      
      
         private static class MessengerHandle extends Handler {
             @Override
             public void handleMessage(Message msg) {
                 switch (msg.what) {
                     case MainActivity.KEY_FROM_CLIENT:
                         Log.e("MessengerService", "收到客户端信息  " + msg.getData().get("msg"));
                         sendClient(msg);
      
                         break;
                     default:
                         break;
                 }
             }
         }
      
         private static void sendClient(Message msg) {
             //得到客户端传来的Messenger对象
             Messenger mMessenger = msg.replyTo;
             Message mMessage = Message.obtain(null, MainActivity.KEY_FROM_CLIENT);
             Bundle mBundle = new Bundle();
             mBundle.putString("msg", "wo是服务端，我们收到信息了,开始愉快的聊天吧");
             mMessage.setData(mBundle);
             try {
                 mMessenger.send(mMessage);
             } catch (RemoteException e) {
                 e.printStackTrace();
             }
         }
      
         private final Messenger mMessenger = new Messenger(new MessengerHandle());
      
         @Override
         public IBinder onBind(Intent intent) {
             return mMessenger.getBinder();
         }
      }
      

   2. 客户端进程：

          public class MainActivity extends AppCompatActivity {
      
      	    public static final int KEY_FROM_CLIENT = 1;
      	
      	    @Override
      	    protected void onCreate(Bundle savedInstanceState) {
      	        super.onCreate(savedInstanceState);
      	        setContentView(R.layout.activity_main);
      	        bindService();
      	    }
      	
      	
      	    @SuppressLint("WrongConstant")
      	    private void bindService() {
      	        Intent intent = new Intent(MainActivity.this, MessengerService.class);
      	        bindService(intent, mServiceConnection, KEY_FROM_CLIENT);
      	
      	    }
      	
      	    Messenger mMessenger;
      	    private ServiceConnection mServiceConnection = new ServiceConnection() {
      	        @Override
      	        public void onServiceConnected(ComponentName name, IBinder service) {
      	            mMessenger = new Messenger(service);
      	            Message mMessage = Message.obtain(null, KEY_FROM_CLIENT);
      	            Bundle mBundle = new Bundle();
      	            mBundle.putString("msg", "看看服务器收到了吗？");
      	            mMessage.setData(mBundle);
      	
      	            //将Messenger传递给服务端
      	            mMessage.replyTo = new Messenger(mHandler);
      	            try {
      	                mMessenger.send(mMessage);
      	            } catch (RemoteException e) {
      	                e.printStackTrace();
      	            }
      	
      	        }
      	
      	        @Override
      	        public void onServiceDisconnected(ComponentName name) {
      	
      	        }
      	    };
      	
      	    private Handler mHandler = new Handler() {
      	
      	        @Override
      	        public void handleMessage(Message msg) {
      	            switch (msg.what) {
      	                case KEY_FROM_CLIENT:
      	                    Log.e("MessengerService", "收到服务端信息  " + msg.getData().get("msg"));
      	                    break;
      	                default:
      	                    break;
      	            }
      	        }
      	    };
      	
      	    @Override
      	    protected void onDestroy() {
      	        super.onDestroy();
      	        unbindService(mServiceConnection);
      	    }
      }
      

   3. manifest注册MessengerService

      <service android:name=".MessengerService" android:process=":remote"/>