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

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[-]
前言
使用时机
AIDL使用
1 创建aidl文件
2 实现接口
3 向客户端暴露接口
4 客户端调用

Messenger的使用
1 服务端
2 客户端
3 客户端发送信息

总结

转载注明出处：http://blog.csdn.net/xiaohanluo/article/details/53911529

1. 前言

提到的进程间通信（IPC：Inter-Process Communication），在Android系统中，一个进程是不能直接访问另一个进程的内存的，需要提供一些机制在不同的进程之间进行通信，Android官方推出了AIDL(Android
Interface Definition Language)，它是基于Binder机制的，至于官方为什么要采用Binder，查看为什么Android要采用Binder作为IPC机制，分析很全面。

上篇Android之Service的细枝末节提到组件在与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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

ParcelableData.aidl

package com.demo.aidl;

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

1
2
3
4
5
6
7
1
2
3
4
5
6
7

IRemoteServiceCallBack.aidl

package com.demo.aidl;

oneway interface IRemoteServiceCallBack {
void valueChanged(int value);
}

1
2
3
4
5
1
2
3
4
5

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

现在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();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

4.3 客户端发送信息

使用Messenger向服务端发送信息，使用的是

Messenger.send(Message)

方法，这个方法具体实现如下：

public void send(Message message) throws RemoteException {
mTarget.send(message);
}

1
2
3
1
2
3

方法内部调用

mTarget.send(Message)

方法，在Messenger中，

mTarget

是在构造方法里面被赋值的，有两个构造函数。

public Messenger(Handler target) {
mTarget = target.getIMessenger();
}

public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}

1
2
3
4
5
6
7
1
2
3
4
5
6
7

第一个构造函数好理解，

mTarget.send(Message)

实际上是将

Message

加入了构造函数传入的Handler的消息队列，Demo工程中服务端向乘客端发送信息就是使用的这种方法

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

5. 总结

到此，从Android之Service的细枝末节到Android中常用的进程通信都已经总结完毕，算是2016的一个完结，撒花！！

最后附上Demo工程地址：https://github.com/Kyogirante/AIDLDemo