Android进程通信之Messenger和AIDL使用详解

1. 前言

提到的进程间通信（ipc：inter-process communication），在android系统中，一个进程是不能直接访问另一个进程的内存的，需要提供一些机制在不同的进程之间进行通信，android官方推出了aidl(android interface definition language)，它是基于binder机制的。

上篇提到组件在与service通信方法有三种。

• 实现ibinder
• messenger
• aidl

后面两种可以跨进程通信，是基于binder机制的通信方式。

2. 使用时机

在确定使用什么机制之前，首先了解应用场景。android系统中，如果组件与服务通信是在同一进程，就使用第一种方式；如果是跨进程通信，使用第二种和第三种，两者不同在于，messenger不能处理多线程并发请求。

3. aidl使用

aidl是可以处理多线程访问的请求的，所以实现aidl首先要保证线程安全。

• 创建.aidl文件，定义接口
• 在代码中实现接口，android sdk会根据aidl文件，生成接口，接口内部有一个名为stub内部抽象类，这个类用于继承了binder类并实现aidl文件中定义的接口，我们需要拓展stub类并实现里面的抽象方法
• 复写service的onbind()，返回stub类的实现
  

3.1 创建.aidl文件

在android studio中工程目录下，反键new -> aidl -> aidl file，可以新建aidl文件，编译器会自动在app(壳工程)/src/main/目录下新建aidl文件，同时也会新建文件夹，默认以工程包名作为aidl文件所在的目录。

目录结构如下：

图-1 aidl文件目录结构

也可以手动创建，aidl接口定义的包名也可以和工程包名不同，aidl文件语法和java语法相似，aidl定义的接口名必须和文件名一致，而且支持传递自定义的数据类型，需要实现parcelable接口。

iremoteservice.aidl

package com.demo.aidl;

import com.demo.aidl.parcelabledata;

interface iremoteservice {
 /**
 * 获取当前进程的pid
 */
 int getpid();
 /**
 * 获取当前服务名称
 */
 string getservicename();
 /**
 * 处理客户端传过来的数据
 */
 void handledata(in parcelabledata data);
}

parcelabledata.aidl

package com.demo.aidl;

/**
 * 声明支持传递的类
 */
parcelable parcelabledata;

iremoteservicecallback.aidl

package com.demo.aidl;

oneway interface iremoteservicecallback {
 void valuechanged(int value);
}

aidl文件定义的接口支持的数据类型如下：

• java的八种基本数据类型（byte，int，short，long，float，double，char，boolean）
• string
• charsequence
• list，list中所有的元素必须是aidl文件支持的数据类型，例如，list< string >
• map，map中所有的元素必须是aidl文件支持的数据类型，
• 其他aidl定义的接口，要手动添加import
• 其他aidl文件中申明的类，要手动添加import
  

aidl文件中定义的方法接受的参数，除了java的基本数据类型和aidl定义的接口之外，其他参数都需要标记数据的走向，in/out/inout，基本数据类型和aidl定义的接口作为参数，默认是in。

• in表示输入参数，客户端把参数传递给服务端使用。
• out表示输出参数，客户端将参数传递给服务端填充，然后自己使用处理。
• inout标书输入输出参数，传送相应的值并接收返回。
  

关键字oneway表示用户请求相应功能时不需要等待响应可直接调用返回，非阻塞效果，该关键字可以用来声明接口或者声明方法，如果接口声明中用到了oneway关键字，则该接口声明的所有方法都采用oneway方式

新建完毕aidl文件后，rebuild工程或者使用gradle assembledebug(或gradle assemblerelease)指令编译工程，生成具体的java代码，在壳工程/build/generated/aidl/目录下的debug或者release文件夹下，根据build的类型而定，如图：

图-2 adil生成代码目录图

aidl接口首次公布后对其的任何修改都必须保持向后兼容性，避免中断客户端对服务的使用，因为需要将.aidl文件复制给其他应用，才能使其他应用能够访问服务，所以必须保持对原始接口的支持。

3.2 实现接口

android sdk会根据.aidl文件生成同名.java文件，生成的接口中有一个stub的抽象子类，这个类实现（implements）aidl定义的接口，同时继承了binder。

具体代码如下：

private final iremoteservice.stub mbinder = new iremoteservice.stub() {
 @override
 public int getpid() throws remoteexception {
 return process.mypid();
 }

 @override
 public string getservicename() throws remoteexception {
 return remoteservice.this.getclass().getsimplename();
 }

 @override
 public void handledata(parcelabledata data) throws remoteexception {
 toast.maketext(remoteservice.this, "num is " + data.num, toast.length_short).show();
 }

 @override
 public void registercallback(iremoteservicecallback cb) throws remoteexception {
 if(cb != null) {
 mcallbacks.register(cb);
 }
 }

 @override
 public void unregistercallback(iremoteservicecallback cb) throws remoteexception {
 if(cb != null) {
 mcallbacks.unregister(cb);
 }
 }
};

现在mbinder是stub类的一个实例，同时也是一个binder，用于服务定义的rpc服务，作为onbind()方法的返回对象实例。

实现aidl接口注意事项：

• 因为aidl可以处理多线程并发，在实现过程中要保证线程安全
• 默认情况下，rpc调用是同步的，但是服务端可能有耗时操作，客户端最好不要在主线程调用服务
• 服务端引发的任何异常不会返回给客户端
  

3.3 向客户端暴露接口

实现接口后，需要向客户端将接口暴露出来，以便客户端使用。将stub的实例化对象作为service中onbind()方法的返回对象。

public class remoteservice extends service {
 /**
 * 回调容器
 */
 private final remotecallbacklist<iremoteservicecallback> mcallbacks = new remotecallbacklist<>();
 /**
 * aidl接口具体实现
 */
 private final iremoteservice.stub mbinder = new iremoteservice.stub() {
 @override
 public int getpid() throws remoteexception {
 return process.mypid();
 }

 @override
 public string getservicename() throws remoteexception {
 return remoteservice.this.getclass().getsimplename();
 }

 @override
 public void handledata(parcelabledata data) throws remoteexception {
 toast.maketext(remoteservice.this, "num is " + data.num, toast.length_short).show();
 }

 @override
 public void registercallback(iremoteservicecallback cb) throws remoteexception {
 if(cb != null) {
 mcallbacks.register(cb);
 }
 }

 @override
 public void unregistercallback(iremoteservicecallback cb) throws remoteexception {
 if(cb != null) {
 mcallbacks.unregister(cb);
 }
 }
 };

 @nullable
 @override
 public ibinder onbind(intent intent) {
 return mbinder;
 }

 @override
 public void ondestroy() {
 // 注销所有回调
 mcallbacks.kill();
 }
}

3.4 客户端调用

服务提供给第三方应用使用，其他应用就必须要有接口类，在客户端创建相同的aidl文件（可以直接拷贝过去）。

核心连接远端服务的代码：

/**
 * 远端服务
 */
private iremoteservice mservice;

private serviceconnection mconnection = new serviceconnection() {
 /**
 * 连接服务器成功回调
 * 
 * @param classname
 * @param service
 */
 public void onserviceconnected(componentname classname, ibinder service) {
 mservice = iremoteservice.stub.asinterface(service);
 }

 /**
 * 服务器因为一场情况断开连接时候回调
 * 
 * @param classname
 */
 public void onservicedisconnected(componentname classname) {
 mservice = null;
 }
};

/**
 * 绑定服务
 */
private void dobindservice() {
 isbound = true;
 intent intent = new intent(bindremoteserviceactivity.this, remoteservice.class);
 bindservice(intent, mconnection, context.bind_auto_create);
}

/**
 * 解除绑定
 */
private void dounbindservice() {
 if(isbound && mservice != null) {
 isbound = false;
 try {
 mservice.unregistercallback(mcallback);
 } catch (remoteexception e) {
 e.printstacktrace();
 }

 unbindservice(mconnection);
 }
}

/**
 * 向服务端发送信息
 */
private void dosendmsg() {
 if(!isbound || mservice == null) {
 return;
 }
 parcelabledata data = new parcelabledata(1);
 try {
 mservice.handledata(data);
 } catch (remoteexception e) {
 e.printstacktrace();
 }
}

/**
 * 调用服务端方法获取信息
 */
private void dogetserviceinfo() {
 if(!isbound || mservice == null) {
 return;
 }
 try {
 string info = mservice.getservicename();

 minfotv.settext("service info :" + info);
 } catch (remoteexception e) {
 e.printstacktrace();
 }
}

详情代码贴上来比较长，贴上工程地址，点我呀！！！

4. messenger的使用

messenger的使用相对于aidl方便好多，因为messenger是android系统中自带的类，服务端和客户端都不用创建aidl文件。

messenger会持有一个handler，这个handler用于处理接受到的信息，在服务端和乘客通过messenger实现双方通信。

4.1 服务端

代码实例：

public class messengerservice extends service {

 public static final int msg_register_client = 0x001;
 public static final int msg_unregister_client = 0x010;
 public static final int msg_handle = 0x100;

 private arraylist<messenger> mclients = new arraylist<>();

 private final messenger mmessenger = new messenger(new incominghandler());

 @nullable
 @override
 public ibinder onbind(intent intent) {
 return mmessenger.getbinder();
 }

 @override
 public void ondestroy() {
 toast.maketext(this, "remote service destroy", toast.length_short).show();
 }

 private class incominghandler extends handler {
 @override
 public void handlemessage(message msg) {
 switch (msg.what) {
 case msg_register_client:
  mclients.add(msg.replyto);
  break;
 case msg_unregister_client:
  mclients.remove(msg.replyto);
  break;
 case msg_handle:
  for (messenger mclient : mclients) {
  try {
  mclient.send(message.obtain(null, msg_handle, msg.arg1, 0));
  } catch (remoteexception e) {
  e.printstacktrace();
  mclients.remove(mclient);
  }
  }
  break;
 default:
  super.handlemessage(msg);
 }
 }
 };
}

4.2 客户端

核心代码：

/**
 * 关联远端服务的messenger
 */
private messenger mservicewrapper;
/**
 * 用于处理服务端发送的信息
 */
final messenger mmessenger = new messenger(new incominghandler());

private serviceconnection mconnection = new serviceconnection() {
 @override
 public void onserviceconnected(componentname name, ibinder service) {
 mservicewrapper = new messenger(service);

 minfotv.settext("connected service");


 try {
 // 添加监听注册
 message msg = message.obtain(null, messengerservice.msg_register_client);
 msg.replyto = mmessenger;
 mservicewrapper.send(msg);
 } catch (remoteexception e) {
 e.printstacktrace();
 }
 }

 @override
 public void onservicedisconnected(componentname name) {
 mservicewrapper = null;
 minfotv.settext("disconnected");
 }
};

/**
 * 绑定服务
 */
private void dobindservice() {
 if(!isbound) {
 bindservice(new intent(this, messengerservice.class), mconnection, context.bind_auto_create);

 isbound = true;

 minfotv.settext("binding...");
 }
}

/**
 * 移除监听并解绑服务
 */
private void dounbindservice() {
 if(isbound) {
 if(mservicewrapper != null) {
 try {
 message msg = message.obtain(null, messengerservice.msg_unregister_client);
 msg.replyto = mmessenger;
 mservicewrapper.send(msg);
 } catch (remoteexception e) {
 e.printstacktrace();
 }
 }

 unbindservice(mconnection);
 isbound = false;
 minfotv.settext("unbinding...");
 }
}

/**
 * 向服务端发送信息
 */
private void dosendmsg() {
 if(mservicewrapper != null) {
 try {
 message msg = message.obtain(null,
  messengerservice.msg_handle, this.hashcode(), 0);
 mservicewrapper.send(msg);
 } catch (remoteexception e) {
 e.printstacktrace();
 }
 }
}

4.3 客户端发送信息

使用messenger向服务端发送信息，使用的是messenger.send(message)方法，这个方法具体实现如下：

public void send(message message) throws remoteexception {
 mtarget.send(message);
}

方法内部调用mtarget.send(message)方法，在messenger中，mtarget是在构造方法里面被赋值的，有两个构造函数。

public messenger(handler target) {
 mtarget = target.getimessenger();
}

public messenger(ibinder target) {
 mtarget = imessenger.stub.asinterface(target);
}

第一个构造函数好理解，mtarget.send(message)实际上是将message加入了构造函数传入的handler的消息队列，demo工程中服务端向乘客端发送信息就是使用的这种方法

第二个构造函数是不是很眼熟，这不就是获取aidl定义的接口嘛！！！转了一圈回到了上面的aidl，客户端向服务端发送信息实际上还是通过aidl，只不过android系统帮我们做了一层封装。

最后附上demo：demo

5. 总结

到此，android中常用的进程通信都已经总结完毕，算是一个完结，撒花！！希望对大家的学习有所帮助，也希望大家多多支持。