Android IPC机制利用Messenger实现跨进程通信

写作原因：跨进程通信的实现和理解是android进阶中重要的一环。下面博主分享ipc一些相关知识、操作及自己在学习ipc过程中的一些理解。这一章使用messenger实现跨进程通信，其中bindservice基础部分参见android ipc机制绑定service实现本地通信。

跨进程简介

在介绍使用messenger跨进程通信之前先要了解以下问题：为什么需要跨进程通信？只有有了需求才有学习的价值。我个人将不同进程简单的理解为不同的应用程序（当然也有例外，比如可以在同一个应用程序中开启两个或多个进程）。由于进程之间不能像线程一样共享内存，所以数据通信不能像线程一般进行。在android中可以使用bundle，广播，messenger，aidl和socket进行跨进程通信。本章利用messenger分别进行单应用程序多进程单向通信和多应用程序多进程双向通信的实现。

messenger介绍

messenger是通过使用message来实现跨进程通信，一次实现一个请求的方式，这是它的优点也是缺点。其底层实现为aidl（下章我将阐述）。messenger的优点是：基于message，方便使用；支持回调的方式，也就是服务端处理完成长任务可以和客户端交互；不需要编写aidl文件。

messenger使用流程如下（转载）：

单应用程序多进程单向通信

先介绍一下android中单应用程序开启多进程的方法，实际上只要在mainfests中的你想开启新进程的组件的xml中添加<android:progress = ":remote(可以自定义)">或者<android:progress = "包.remote(可以自定义)">就行。如：

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

这样就把service放在新的线程中运行了。

service实现

 下面是服务端的代码实现，具体思路是：创建一个handler对象用来处理客户端发送来的消息，再创建一个messenger对象将上面的handler对象作为参数传入，这样我们就获得了一个信使。下面就是通过getbinder()把这个信使创建的binder对象返回给客户端（一旦客户端拿到这个binder，又可以将它还原为messenger）。handler中处理信息为：当得到的message的what值为msg_say_hello时输出toast。

public class customservice extends service{
  static final int msg_say_hello = 1;
  //实现一个能够处理接收信息的handler
  class incominghandler extends handler{
    @override
    public void handlemessage(message msg) {
      super.handlemessage(msg);
      switch(msg.what){
        case msg_say_hello:
          toast.maketext(getapplicationcontext(),"hello!",toast.length_short).show();
          break;
        default:
          super.handlemessage(msg);
      }
    }
  }
  //被客户端接收的messenger对象
  final messenger messenger = new messenger(new incominghandler());
  @override
  public ibinder onbind(intent intent) {
    toast.maketext(getapplicationcontext(),"binding!",toast.length_short).show();
    return messenger.getbinder();
  }
}

 activity实现

 在客户端中我们应该做的是：拿到服务端传来的messenger对象（在serviceconnection中取得，具体参见上一篇文章），然后创建一个message对象，为message写入数据，注意message中的what要与服务端中handler对象中的what一致。使用该messenger通过send()将message发送给服务端，这样就可以实现客户端与服务端的单向通信了。

具体代码如下：

 

public class mainactivity extends appcompatactivity {
  private button mbtstart;
  private messenger messenger = null;
  private boolean mbound;
  private textview mtvmsg;
  private serviceconnection serviceconnection = new serviceconnection() {
    @override
    public void onserviceconnected(componentname name, ibinder service) {
      messenger = new messenger(service);
      mbound = true;
    }

    @override
    public void onservicedisconnected(componentname name) {
      messenger = null;
      mbound = false;
    }
  };
  public void sayhello(view v){
    if(!mbound) return;
    message msg = message.obtain(null,customservice.msg_say_hello,0,0);
    try{
      messenger.send(msg);
    }catch (remoteexception e){
      e.printstacktrace();
    }
  }
  @override
  protected void oncreate(bundle savedinstancestate) {
    super.oncreate(savedinstancestate);
    setcontentview(r.layout.activity_main);
    mbtstart = (button) findviewbyid(r.id.bt_start);
    mtvmsg = (textview) findviewbyid(r.id.tv_msg);
    mbtstart.setonclicklistener(new view.onclicklistener() {
      @override
      public void onclick(view v) {
        intent intent = new intent(mainactivity.this,customservice.class);
        bindservice(new intent(mainactivity.this,customservice.class),serviceconnection, context.bind_auto_create);
      }
    });
  }
  @override
  protected void onstop() {
    super.onstop();
    // unbind from the service
    if (mbound) {
      unbindservice(serviceconnection);
      mbound = false;
    }
  }
}

 以上过程一开始理解可能会有些抽象，多动手才能加深理解。

 多应用程序多进程双向通信

仍然以activity和service通信为例，不过这次我们需要新建两个module（clientapp和serviceapp），clientapp中就一个activity，serviceapp中一个service（关于没有activity的app的启动方式自行百度）。这样就是两个应用程序两个进程的情况了。

下面开始分析这种情况下的messenger的用法：

service实现

依然是先从service开始。大致思路与上面的service的创建类似，但又一点不同的是，这次我们需要新建一个clientmessenger来实现service向客户端发送message操作。在service的handler中有这样一段代码，

clientmessenger = msg.replyto;//这个message是在客户端中创建的
        if(clientmessenger!=null){
          message msgtoclient = message.obtain();
          msgtoclient.what = send_message_code;
          bundle bundle = new bundle();
          bundle.putstring("msg","客户端，我接收到你的消息了，这是我回应给你的，看到了吗？");
          msgtoclient.setdata(bundle);
          try {
            clientmessenger.send(msgtoclient);
          } catch (remoteexception e) {
            e.printstacktrace();
          }
        }

上面代码用来接收到客户端发送来的数据后向客户端发送数据作出回应。注意这里的clientmessenger = msg.replyto;，是指从客户端中取出与msg一道捆绑过来的clientmessenger对象。利用clientmessenger就可以实现向activity中返回数据了。

详细代码如下：

public class myservice extends service {
  private static final int receive_message_code = 0x0001;
  private static final int send_message_code = 0x0002;

  private messenger clientmessenger = null;
  private messenger servicemessenger = new messenger(new servicehandler());
  @override
  public ibinder onbind(intent intent) {
    return servicemessenger.getbinder();
  }

  @override
  public void oncreate() {
    super.oncreate();
  }

  @override
  public void ondestroy() {
    super.ondestroy();
    clientmessenger = null;
  }

  private class servicehandler extends handler{
    @override
    public void handlemessage(message msg) {
      super.handlemessage(msg);
      if(msg.what == receive_message_code){
        bundle data = msg.getdata();
        if(data != null){
          string str = data.getstring("msg");
          toast.maketext(getapplicationcontext(),"service:i received the message:"+str,toast.length_short).show();
        }
        clientmessenger = msg.replyto;//这个message是在客户端中创建的
        if(clientmessenger!=null){
          message msgtoclient = message.obtain();
          msgtoclient.what = send_message_code;
          bundle bundle = new bundle();
          bundle.putstring("msg","客户端，我接收到你的消息了，这是我回应给你的，看到了吗？");
          msgtoclient.setdata(bundle);
          try {
            clientmessenger.send(msgtoclient);
          } catch (remoteexception e) {
            e.printstacktrace();
          }
        }
      }

    }
  }
}

activity实现：

activity中主要是实现绑定发送数据和解除绑定两大块功能。绑定先发送显式intent（5.0以上不支持隐式启动service，具体操作见下面的启动过程）绑定service，当绑定成功后获取messenger对象并使用该对象发送message对象msg给service，具体操作与上面的一样。这里有一点不一样的是，为了能够使得service能获得clientmessenger，我们必须手动将msg与clientmessenger关联，即：msg.replyto = clientmessenger;。这样service在获得activity发送过来的message的同时也可以取到clientmessenger。而clientmessenger必须先创建出来，方法与单向获取时一致。

详细代码如下：

public class mainactivity extends appcompatactivity{
  private button mbtbind;
  private button mbtunbind;
  private textview mtvmsg;

  private static final int send_message_code = 0x0001;
  private static final int receive_message_code = 0x0002;
  private boolean isbound = false;

  private string service_action = "com.example.serviceapp.myservice";

  private messenger servicemessenger = null;

  private messenger clientmessenger = new messenger(new clienthandler());
  @override
  protected void oncreate(bundle savedinstancestate) {
    super.oncreate(savedinstancestate);
    setcontentview(r.layout.activity_main);
    mbtbind = (button) findviewbyid(r.id.bt_bind);
    mbtunbind = (button) findviewbyid(r.id.bt_unbind);
    mtvmsg = (textview) findviewbyid(r.id.tv_msg);
    mbtunbind.setonclicklistener(new view.onclicklistener() {
      @override
      public void onclick(view v) {
        if(isbound){
          unbindservice(serviceconnection);
        }
      }
    });
    mbtbind.setonclicklistener(new view.onclicklistener() {
      @override
      public void onclick(view v) {
        if(!isbound){
          intent intent = new intent();
          intent.setaction(service_action);
          intent.addcategory(intent.category_default);
          packagemanager pm = getpackagemanager();
          resolveinfo info = pm.resolveservice(intent,0);
          if(info != null){
            string packagename = info.serviceinfo.packagename;
            string servicename = info.serviceinfo.name;
            componentname componentname = new componentname(packagename,servicename);
            intent.setcomponent(componentname);
            bindservice(intent,serviceconnection,bind_auto_create);
          }
        }
      }
    });
  }
  private serviceconnection serviceconnection = new serviceconnection() {
    @override
    public void onserviceconnected(componentname name, ibinder service) {
      servicemessenger = new messenger(service);
      isbound = true;
      message msg = message.obtain();
      msg.what = send_message_code;
      bundle data = new bundle();
      data.putstring("msg","你好，myservice，我是客户端");
      msg.setdata(data);
      msg.replyto = clientmessenger;
      try {
        servicemessenger.send(msg);
      } catch (remoteexception e) {
        e.printstacktrace();
      }
    }

    @override
    public void onservicedisconnected(componentname name) {
      servicemessenger = null;
      isbound = false;
    }
  };
  private class clienthandler extends handler{
    @override
    public void handlemessage(message msg) {
      super.handlemessage(msg);
      if(msg.what == receive_message_code){
        bundle data = msg.getdata();
        if(data != null){
          string str = data.getstring("msg");
          mtvmsg.settext(str);
        }
      }
    }
  }
}

总结：

这一块理解起来可能比较吃力，所以希望读者多加尝试，为后面的aidl跨通信方式学习做准备。