Android进程间通信(3)-Messenger实现

前面两篇文章中已经介绍了两种实现进程间通信的方式，那是不是只有这两种方式实现进程间通信呢？当然不是，还有更好的实现方式，那就是Messenger。本篇文章将带领大家一起来学习下Messenger.

• 基于aidl实现的进程通信
• 基于纯代码实现的进程通信

没有看我写的上面两篇文章的同学，建议先去看下上面两篇文章，以更好的理解。

什么是基于消息的进程通信？

该图片是引用自弘扬大神的博客

其实基于消息的进程通信就是客户端通过Handler发送一条Message，服务端收到这条Message然后获取到客户端的值，服务端进行处理，再将结果封装成Message传递给客户端。通过这种方式实现aidl有什么好处呢？

• 不用再写aidl文件了（很多同学一提到aidl就头疼）
• 基于Message，这个大家已经很熟悉了

接下来我们通过代码详细的介绍下。

1，服务端，我们定义一个MessengerService.java的Service，代码如下：

package com.wms.github.aidl.server;

import android.app.Service;
import android.content.Intent;
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;

/**
 * Created by 王梦思 on 2017/5/25.
 */

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    private Messenger messenger = new Messenger(new Handler() {
        @Override
        public void handleMessage(Message clientMsg) {
            if (clientMsg.what == 0x001) {
                //注意这个里clientMsg是客户端发送过来的消息
                Bundle bundle = (Bundle) clientMsg.obj;
                String str = bundle.getString("str");
                str = str.toUpperCase();
                //服务端处理完逻辑后，将数据通过Messeage的方式传递给客户端
                Message message = Message.obtain();
                Bundle sendBundle = new Bundle();
                sendBundle.putString("str", str);
                message.obj = sendBundle;
                message.what = 0x001;
                try {
                    //将消息发送到客户端
                    clientMsg.replyTo.send(message);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            super.handleMessage(clientMsg);
        }
    });

    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind...");
        //这里不能返回null，必须要返回我们创建的Binder对象
        return messenger.getBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG, "onUnbind...");
        return super.onUnbind(intent);
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Log.e(TAG, "onStart...");
        super.onStart(intent, startId);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand...");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onCreate() {
        Log.e(TAG, "onCreate...");
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        Log.e(TAG, "onDestroy...");
        super.onDestroy();
    }
}

服务端就一个Service，可以看到代码相当的简单，只需要去声明一个Messenger对象，然后onBind方法返回messenger.getBinder()；
然后坐等客户端将消息发送到handleMessage想法，根据message.what去判断进行什么操作，然后做对应的操作，最终将结果通过 clientMsg.replyTo.send()，这里注意一定要调用clientMsg.replyTo.send()去发送消息，不然客户端接收不到。

注册MessengerService

<service
            android:name="com.wms.github.aidl.server.MessengerService"
            android:exported="true">
            <intent-filter>
                <action android:name="com.wms.github.aidl.server.MessengerService"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </service>

2，客户端。在客户端我新建一个MessengerActivity.java，代码如下：

package com.wms.github.aidl.client;

import android.content.ComponentName;
import android.content.Context;
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.EditText;

/**
 * Created by 王梦思 on 2017/5/25.
 */

public class MessengerActivity extends MainActivity {
    private EditText mEditText;
    private Messenger mService;

    private Messenger clientMessenger = new Messenger(new Handler() {
        @Override
        public void handleMessage(Message msg) {

            if (msg.what == 0x001) {
                Bundle bundle = (Bundle) msg.obj;
                mEditText.setText(bundle.getString("str"));
            }

            super.handleMessage(msg);
        }
    });

    private ServiceConnection mServiceConn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //当绑定成功后调用
            Log.e("MainActivity", "onServiceConnected...");
            mService = new Messenger(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("MainActivity", "onServiceDisconnected...");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mEditText = (EditText) findViewById(R.id.id_edittext);

        findViewById(R.id.bind).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bindService();
            }
        });

        findViewById(R.id.unbind).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unBindService();
            }
        });

        findViewById(R.id.invokeServer).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                invokeServer();
            }
        });
    }

    /**
     * 绑定服务
     */
    public void bindService() {
        Intent intent = new Intent();
        intent.setAction("com.wms.github.aidl.server.MessengerService");
        //Android 5.0以上必须要加这句代码，不然报错
        intent.setPackage("com.wms.github.aidl.server");
        bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);
    }

    public void unBindService() {
        unbindService(mServiceConn);
    }

    public void invokeServer() {
        String inputStr = mEditText.getText().toString().trim();
        try {
            Message message = Message.obtain();
            message.what = 0x001;
            Bundle bundle = new Bundle();
            bundle.putString("str",inputStr);
            message.obj = bundle;

            //将消息的回应设置为clientMessenger，这样客户端发送消息就能在客户端收到了。
            message.replyTo = clientMessenger;
            mService.send(message);
        } catch (RemoteException e) {
            //这里会抛出远程异常
            e.printStackTrace();
        }
    }
}

布局文件和上篇文章中一样。

MessengerActivity.java中代码也很简单，就是绑定一个服务，然后再onServiceConnect中实例化一个Messenger，这个Messenger和MessengerActivity中属性clientMessenger不一样，因为这个Messenger实例化的时候把Binder驱动传递进来了。所以当客户端调用mService.send(message); 后，服务端将会收到客户端传递过来的数据，服务端处理完之后，返回到Client端的clientMessenger中的Handler的handleMessage方法中，这样就完成了客户端和服务端的通信。

效果图：

当我们点击调用服务端转换后，服务端就把大写字母回传给客户端。以上就是简单的Messenger的使用，肯定很多人有疑问，为什么这样可以实现进程间的通信呢？下面我将带领大家一起来从源码的角度来看看。

1，先分析服务端，服务端中onBind()方法里面我们返回了messenger.getBinder(); 很简单，就一行代码，我们进入Messenger的内部看下getBinder内部到底做了什么事情

/**
     * Retrieve the IBinder that this Messenger is using to communicate with
     * its associated Handler.
     * 
     * @return Returns the IBinder backing this Messenger.
     */
    public IBinder getBinder() {
        return mTarget.asBinder();
    }

getBinder方法也很简单，也就一行代码。这里mTarget是什么呢？查看下源码，private final IMessenger mTarget; 可以看出mTarget是一个IMessenger对象，mTarget赋值是在我们实例化clientMessenger对象的时候Messenger构造方法里面。我们再来看看Messenger的构造方法

/**
     * 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();
    }

继续跟进到Handler内部的getImessenger方法

final IMessenger getIMessenger() {
        synchronized (mQueue) {
            if (mMessenger != null) {
                return mMessenger;
            }
            mMessenger = new MessengerImpl();
            return mMessenger;
        }
    }

恍然大悟，原来mTarget其实是一个MessengerImpl对象。再回到Messenger中的getBinder方法，其实就是调用了MessengerImpl内部的asBinder方法，我们进入到MessengerImpl中的asBinder中看看其内部做了什么事情。

MessengerImpl原来是继承自IMessenger.Stub，是不是很熟悉？这不又回到了我们前面的文章中通过aidl实现进程通信的了么？原来Android内部已经帮我们实现了一个IMessenger.aidl文件，这个文件位于framework中的platform_frameworks_base/core/java/android/os/IMessenger.aidl，大家可以下载framework源代码去查看下。由于aidl代码较少，我下面贴出IMessenger.aidl内部代码如下：

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

哇，好简答，就一个send方法，send方法里面传递的是一个Message对象。所以这一切又回到了我们前面所说的aidl进行进程通信的内容了。如果不明白的可以看我之前写过的一篇文章 基于aidl实现的进程通信

2，接下来我们分析下客户端源代码
当客户端调用绑定服务的时候，会调用onServiceConnect方法

private ServiceConnection mServiceConn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //当绑定成功后调用
            Log.e("MainActivity", "onServiceConnected...");
            mService = new Messenger(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("MainActivity", "onServiceDisconnected...");
        }
    };

在onServiceConnected中我们实例化了一个Messenger，并且传递了一个IBinder对象，这个IBinder对象就是一直说的Binder驱动。我们进入Messenger这个构造函数中看看：

/**
     * 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);
    }

是不是又很熟悉？这不就是我们在 基于aidl实现的进程通信 中onSeviceConnect方法实现的一样么？

综上分析客户端和服务端的源代码，其实和我们写aidl完全一样，没有任何区别，Messenger底层其实就是基于aidl来实现的进程通信，只是Android内部已经给我们写好了一个IMessnger.aidl文件，不需要我们手动实现了。

到此，我们就已经分析完了源码了，如果还是不明白的同学建议去翻看下Messenger的源码，并不复杂，到此Android中实现进程通信的常用方式已经介绍完了。

代码传送门 : http:github.com/wms1993/blog_aidl_demo