进程通信---Messenger

一.Messager介绍

Messager，故名思义信使的意思，能够完成跨进程通信。和Service结合使用（服务器端是个service，得在Manifest文件中注册哦）
Messenger与Handler类似，可以用它来发送和处理消息，其底层的实现是对Binder，对ALDl的一个简单封装。（Messenger是对AIDL的封装，AIDL又是基于Binder机制实现的）
使用起来也比较简洁，在一个线程中通过指定一个Handler来创建Messenger，并把它传递给另一个进程，这样两个进程之间就可以通过消息（Message）来传递信息了。

二.Messager的原理

三、使用方法

主要思路：
客户端通过bindService来绑定服务端，并从服务端获得IBinder接口用于创建服务端的Messenger实例，这样客户端就可以通过这个服务端的Messenger实例发送Message给服务器。其中，客户端的Messenger实例可以通过Message的replyTo参数传递给服务端。经过上述过程，客户端和服务端就各自获得了对方的Messenger实例，进而实现两个进程间的通信。

服务端：

接受消息： 创建Messager信使对象，参数为handler
发送消息：获得客户端的信使对象
Messenger clientMessager = msg.replyTo;

客户端

接受消息： 创建Messager信使对象，参数为handler
发送消息：绑定服务成功创建Server端的Messager，参数为binder

Messenger的初始化过程就是建立Messenger对象、IMessenger接口类对象和Handler对象三者之间的关联，Hanlder类可以看做是最终服务的提供者。

四、使用Messager到项目里

private IServiceConnect mServiceConnect;
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName name, IBinder service) {
            NavigationManager.this.mServiceConnect.onServiceConnected();
            NavigationManager.this.mIsBound = true;
            NavigationManager.this.mService = new Messenger(service);
            Message msg = Message.obtain((Handler)null, 1);
            msg.replyTo = NavigationManager.this.mMessenger;

            try {
                NavigationManager.this.mService.send(msg);
                NavigationManager.this.mService.getBinder().linkToDeath(NavigationManager.this.mDeathRecipient, 0);
            } catch (RemoteException var5) {
                var5.printStackTrace();
            }

            Log.d(NavigationManager.TAG, "onServiceConnected: ");
        }

        public void onServiceDisconnected(ComponentName name) {
            Log.d(NavigationManager.TAG, "onServiceDisconnected: ");
            NavigationManager.this.mServiceConnect.onServiceDisconnected();
            NavigationManager.this.mIsBound = false;
            NavigationManager.this.mService = null;
        }
    };
    private DeathRecipient mDeathRecipient = new DeathRecipient() {
        public void binderDied() {
            Log.d(NavigationManager.TAG, "binderDied: ");
            if (NavigationManager.this.mService != null) {
                NavigationManager.this.mService.getBinder().unlinkToDeath(NavigationManager.this.mDeathRecipient, 0);
            }

            NavigationManager.this.mServiceConnect.onServiceDisconnected();
            NavigationManager.this.mService = null;
            NavigationManager.this.mIsBound = false;
        }
    };
    final Messenger mMessenger = new Messenger(new NavigationManager.IncomingHandler());

    public NavigationManager(Context context) {
        this.mContext = context;
    }

    public void connect(IServiceConnect connect) {
        Intent intent = new Intent();
        intent.setClassName("com.edith.os", "com.edith.applications.navigation.NavigationService");
        boolean bound = this.mContext.bindService(intent, this.mConnection, 1);
        this.mServiceConnect = connect;
        Log.d(TAG, "bindNaviService: bound = " + bound);
    }

    public void disconnect() {
        if (this.mIsBound) {
            if (this.mService != null) {
                try {
                    Message msg = Message.obtain((Handler)null, 2);
                    msg.replyTo = this.mMessenger;
                    this.mService.send(msg);
                } catch (RemoteException var2) {
                    var2.printStackTrace();
                }
            }

            this.mService = null;
        }

        this.mIsBound = false;
        this.mContext.unbindService(this.mConnection);
    }

    public boolean isConnected() {
        return this.mIsBound;
    }

    public void sendData(String info, Bitmap bitmap) {
        Log.d(TAG, "sendData: info = " + info + ", bitmap = " + bitmap);
        Message msg = Message.obtain((Handler)null, 3);
        Bundle bundle = new Bundle();
        bundle.putString("navi_info", info);
        bundle.putParcelable("navi_bitmap", bitmap);
        if (this.mService != null) {
            try {
                msg.setData(bundle);
                msg.replyTo = this.mMessenger;
                this.mService.send(msg);
            } catch (RemoteException var6) {
                var6.printStackTrace();
            }
        }

    }

    public void sendData(Bundle bundle) {
        Message msg = Message.obtain((Handler)null, 3);
        if (this.mService != null) {
            try {
                msg.setData(bundle);
                msg.replyTo = this.mMessenger;
                this.mService.send(msg);
            } catch (RemoteException var4) {
                var4.printStackTrace();
            }
        }

    }

    public void registerBtConnectListener(IBtConnectCallback callback) {
        this.mCallbacks.add(callback);
        Log.d(TAG, "registerBtConnectListener: mCallbacks = " + this.mCallbacks.size());
    }

    public void unregisterBtConnectListener(IBtConnectCallback callback) {
        this.mCallbacks.remove(callback);
    }

    class IncomingHandler extends Handler {
        IncomingHandler() {
        }

        public void handleMessage(Message msg) {
            switch(msg.what) {
            case 4:
                boolean connected = (Boolean)msg.obj;

                for(int i = 0; i < NavigationManager.this.mCallbacks.size(); ++i) {
                    ((IBtConnectCallback)NavigationManager.this.mCallbacks.get(i)).onConnected(connected);
                }

                return;
            default:
                super.handleMessage(msg);
            }
        }
    }

Demo

https://gitee.com/peter_RD_nj/DemoAllInOne/tree/master/MessengerDemo

五、Messenger与AIDL的区别

目前安卓的各种第三方推送服务都是采用多路复用的技术，即多个app共享一个后台service，一条长连接处理多个app的推送任务。

进程间通信，AIDL和Messenger。

1. Messenger是对AIDL的一种封装，开发的时候不用再写.aidl文件。

结合我自身的使用，因为不用去写.aidl文件，相比起来，Messenger使用起来十分简单。但前面也说了，Messenger本质上也是AIDL，故在底层进程间通信这一块，两者的效率应该是一样的。

2. service端，Messenger处理client端的请求是单线程的，而AIDL是多线程的。

使用AIDL的时候，service端每收到一个client端的请求时，就会启动一个线程去执行相应的操作。而Messenger，service收到的请求是放在Handler的MessageQueue里面，Handler大家都用过，它需要绑定一个Thread，然后通过Looper不断循环取出message执行相关操作，这个过程是同步执行的。但是你也可以不直接处理请求，而是开启线程或者使用线程池，这样也可以实现异步。

3. client端，使用AIDL获取返回值是同步的，而Messenger是异步的。

Messenger只提供了一个方法进行进程间通信，就是send(Message msg)方法，发送的是一个Message，没有返回值，要拿到返回值，需要把client的Messenger作为msg.replyTo参数传递过去，service端处理完之后，在调用客户端的Messenger的send(Message msg)方法把返回值传递回client，这个过程是异步的，而AIDL你可以自己指定方法，指定返回值，它获取返回值是同步的。