Android:IPC之AIDL的学习和总结

为了使得一个程序能够在同一时间里处理许多用户的要求。即使用户可能发出一个要求,也肯能导致一个操作系统中多个进程的运行(PS:听音乐,看地图)。而且多个进程间需要相互交换、传递信息,IPC方法提供了这种可能。IPC方法包括管道(PIPE)、消息排队、旗语、共用内存以及套接字(Socket)。

Android中的IPC方式有Bundle、文件共享、Messager、AIDL、ContentProvider和Socket。
这次我们学习的是Android中的AIDL。

概述

AIDL(Android接口描述语言)是一个IDL语言,它可以生成一段代码,可以是一个在Android设备上运行的两个进程使用内部通信进程进行交互。在Android上,一个进程通常无法访问另一个进程的内存。所以说,如果你想在一个进程中(例如在一个Activity中)访问另一个进程中(例如service)某个对象的方法,你就可以使用AIDL来生成这样的代码来伪装传递各种参数。

语法

AIDL它和Java基本上类似,只是有一些细微的差别(PS:可能Google为了方便Android程序猿使用)。AIDL使用简单的语法来声明接口,描述其方法以及方法的参数和返回值。这些参数和返回值可以是任何类型,甚至是其他AIDL生成的接口。重要的是必须导入所有非内置类型,哪怕是这些类型是在与接口相同的包中。

下边说说AIDL的一些特点:

  • 通常引引用方式传递的其他AIDL生成的接口,必须要import 语句声明。
  • Java编程语言的主要类型 (int, boolean等) —不需要 import 语句。
  • 在AIDL文件中,并不是所有的数据类型都是可以使用的,那么到底AIDL文件中支持哪些数据类型呢?
    如下所示:
    1、基本数据类型(int,long,char,boolean,float,double,byte,short八种基本类型);
    2、String和CharSequence;
    3、List:只支持ArrayList,里面每个元素都必须能够被AIDL支持;
    4、Map:只支持HashMap,里面的每个元素都必须被AIDL支持,包括key和value;
    5、Parcelable:所有实现了Parcelable接口的对象;
    6、AIDL:所有的AIDL接口本身也可以在AIDL文件中使用;
    以上6中数据类型就是AIDL所支持的所有类型,其中自定义的Parcelable对象和AIDL对象必须要显式import进来,不管它们是否和当前的AIDL文件位于同一个包内。

需要注意的地方:
AIDL中除了基本数据类型,其他类型的参数必须标上方向:in、out或者inout;
(PS:假若传递一个Book对象且没有加指向tag时,则会抛出”aidl.exe E 4928 5836 type_namespace.cpp:130] ‘Book’ can be an out type, so you must declare it as in, out or inout.”异常)

  • in表示输入型参数(Server可以获取到Client传递过去的数据,但是不能对Client端的数据进行修改)
  • out表示输出型参数(Server获取不到Client传递过去的数据,但是能对Client端的数据进行修改)
  • inout表示输入输出型参数(Server可以获取到Client传递过去的数据,但是能对Client端的数据进行修改)。
    更多tag相关的内容:AIDL源码解析in、out和inout

使用AIDL实现IPC

实现步骤 (官网AIDL样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// IRemoteService.aidl
package com.example.android;

// Declare any non-default types here with import statements

/** Example service interface */
interface IRemoteService {
/** Request the process ID of this service, to do evil things with it. */
int getPid();

/** Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/

void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
double aDouble, String aString)
;

}

这是官网创建的一个简单的AIDL文件。

这次我们自己声明一个包含非默认支持类型的AIDL文件。
AIDL要跨进程通信,其所携带的数据也需要跨进程传输。所以我们首先需要自定自己想要传输的数据类必须其必须实现Parcelable接口从而可以被序列化。
为什么需要序列化呢,为什么不适用Serializable,不知道的同学可以看下这篇文章: Serializable和Parcelable的再次回忆
所以我们先创建需要传输的数据所对应的aidl文件,然后再相同目录下创建对应的Java类文件。这里可能有些同学会疑惑,不是直接创建Java类么。AIDL文件有两种类型,一种是我们上边定义的接口,而另外一种就是非常规类型的数据对象文件。即:如果AIDL文件中用到了自定义的Parcelable对象,那么必须新建一个和它同名的AIDL文件,并在其中声明它为Parcelable类型。详细的使用我们看下边例子:

创建一个Book.aidl文件

在Android Studio的项目中先创建对应的aidl包,然后右击选择创建aidl文件,so easy。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Book.aidl
package com.tzx.aidldemo.aidl;

// Declare any non-default types here with import statements
//所有注释掉的内容都是Android Studio帮你写的,但是我们不需要。
//我们创建的是aidl数据对象,所以我们只需写出parcelable 后面跟对象名。
//parcelabe前的字母‘p’是小写的哦~
parcelable Book;
//interface Book {
//
// /**
// * Demonstrates some basic types that you can use as parameters
// * and return values in AIDL.
// */
// void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
// double aDouble, String aString);
//}

在Book.aidl的包下创建Book.java类文件

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
public class Book implements Parcelable {
public int bookId;
public String bookName;

public Book() {
}

public Book(int bookId, String bookName) {
this.bookId = bookId;
this.bookName = bookName;
}
//从序列化后的对象中创建原始对象
protected Book(Parcel in) {
bookId = in.readInt();
bookName = in.readString();
}

public static final Creator<Book> CREATOR = new Creator<Book>() {
//从序列化后的对象中创建原始对象
@Override
public Book createFromParcel(Parcel in) {
return new Book(in);
}
//指定长度的原始对象数组
@Override
public Book[] newArray(int size) {
return new Book[size];
}
};
//返回当前对象的内容描述。如果含有文件描述符,返回1,否则返回0,几乎所有情况都返回0
@Override
public int describeContents() {
return 0;
}
//将当前对象写入序列化结构中,其flags标识有两种(1|0)。
//为1时标识当前对象需要作为返回值返回,不能立即释放资源,几乎所有情况下都为0.
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(bookId);
dest.writeString(bookName);
}

@Override
public String toString() {
return "[bookId=" + bookId + ",bookName='" + bookName + "']";
}
}

在Android Studio中如果先创建Java类文件,然后创建AIDL文件则会提示命名重复,但顺序反过来就可以。

创建aidl接口文件IBookManager.aidl

1
2
3
4
5
6
7
8
// IBookManager.aidl
package com.tzx.aidldemo.aidl;
//通常引用方式传递自定义对象,必须要import语句声明
import com.tzx.aidldemo.aidl.Book;
interface IBookManager {
List<Book> getBookList();
void addBook(in Book book);
}

这样所有aidl相关的文件就定义完了,我们可以写客户端和服务端了么。然而实际结果表明我们还是无法在客户端或服务费使用aidl类。在这里说一下其实aidl方式只不过是为我们提供模板自动创建aidl对应的Java类文件,只有生成了对应的Java文件之后我们才可以在客户端或服务端使用。Android studio中make一下当前的project就会在项目的app/build/source/aidl/包名/debug这个目录下生成对应的aidl类文件(PS:只有aidl接口文件才会生成java类文件)。

make的时候可能提示找不到对应的Book.java文件,我们可以在build.gradle文件中的android{}标签里面添加:

1
2
3
4
5
sourceSets{
main{
aidl.srcDirs = ['src/main/java']
}
}

这种情况只适合aidl类文件和对应的java类文件在同一个包下。

好了,现在所有的aidl文件都有了,我们开始写我们的服务交互了~!~!

服务端:

Service服务

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
/**
* Created by tanzhenxing
* Date: 2016/10/17.
* Description:远程服务
*/

public class BookManagerService extends Service {
//支持并发读写
private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();
//服务端定义Binder类(IBookManager.Stub)
private Binder mBinder = new IBookManager.Stub() {

@Override
public List<Book> getBookList() throws RemoteException {
return mBookList;
}

@Override
public void addBook(Book book) throws RemoteException {
mBookList.add(book);
}
};
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
}

并在Manifest文件中声明,将它放在一个新的进程中,这样方便我们演示跨进程通信。

1
2
<service android:name=".BookManagerService"
android:process=":server"/>

客户端:

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/**
* Created by tanzhenxing
* Date: 2016/10/17.
* Description:主界面
*/

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private EditText bookNameTV;
private Button bookAddTV;
private Button bookCountTV;
private TextView bookInfoTV;
private Intent bookManagerIntent;
private boolean mBound = false;
private IBookManager bookManager;
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//客户端获取代理对象
bookManager = IBookManager.Stub.asInterface(service);
}

@Override
public void onServiceDisconnected(ComponentName name) {

}
};

@Override
protected void onStart() {
super.onStart();
bookManagerIntent = new Intent(this, BookManagerService.class);
bindService(bookManagerIntent, mConnection, Context.BIND_AUTO_CREATE);
mBound = true;
}

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

}


private void initView() {
bookNameTV = (EditText) findViewById(R.id.book_name);
bookAddTV = (Button) findViewById(R.id.book_add);
bookCountTV = (Button) findViewById(R.id.book_count);
bookInfoTV = (TextView) findViewById(R.id.book_info);
}

private void initListener() {
bookAddTV.setOnClickListener(this);
bookCountTV.setOnClickListener(this);
}


@Override
protected void onStop() {
super.onStop();
if (mBound) {
mBound = false;
unbindService(mConnection);
}
}

@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.book_add:
addBook();
break;
case R.id.book_count:
getBookList();
break;
}
}

private void addBook() {
if (bookManager != null && !TextUtils.isEmpty(bookNameTV.getText().toString())) {
Book book = new Book((int) System.currentTimeMillis(), bookNameTV.getText().toString());
try {
bookManager.addBook(book);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}

public void getBookList() {
try {
if (bookManager != null) {
List<Book> list = bookManager.getBookList();
if (list != null && list.size() > 0) {
StringBuilder builder = new StringBuilder();
for (Book book : list) {
builder.append(book.toString());
builder.append('\n');
}
bookInfoTV.setText(builder.toString());
} else {
bookInfoTV.setText("Empty~!");
}
}
} catch (RemoteException e) {
e.printStackTrace();
}
}
}

运行结果

AIDLDEMO

解析aidl生成的java类

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
public interface IBookManager extends android.os.IInterface {
//根据aidl文件中定义的方法,进行接口声明
public java.util.List<com.tzx.aidldemo.aidl.Book> getBookList()
throws android.os.RemoteException;
//根据aidl文件中定义的方法,进行接口声明
public void addBook(com.tzx.aidldemo.aidl.Book book)
throws android.os.RemoteException;


/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.tzx.aidldemo.aidl.IBookManager {
private static final java.lang.String DESCRIPTOR = "com.tzx.aidldemo.aidl.IBookManager";
//定义方法执行code,与客户端同步
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION +
0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION +
1);

/** Construct the stub at attach it to the interface. */
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}

/**
* Cast an IBinder object into an com.tzx.aidldemo.aidl.IBookManager interface,
* generating a proxy if needed.
*/

public static com.tzx.aidldemo.aidl.IBookManager asInterface(
android.os.IBinder obj)
{

if ((obj == null)) {
return null;
}

android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);

if (((iin != null) &&
(iin instanceof com.tzx.aidldemo.aidl.IBookManager))) {
return ((com.tzx.aidldemo.aidl.IBookManager) iin);
}
//生成代理对象
return new com.tzx.aidldemo.aidl.IBookManager.Stub.Proxy(obj);
}

@Override
public android.os.IBinder asBinder() {
return this;
}

@Override
public boolean onTransact(int code, android.os.Parcel data,
android.os.Parcel reply, int flags)

throws android.os.RemoteException {

switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);

return true;
}

case TRANSACTION_getBookList: {
data.enforceInterface(DESCRIPTOR);
//调用服务端getBookList()
java.util.List<com.tzx.aidldemo.aidl.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);

return true;
}

case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);

com.tzx.aidldemo.aidl.Book _arg0;

if ((0 != data.readInt())) {
_arg0 = com.tzx.aidldemo.aidl.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
//调用服务端addBook()
this.addBook(_arg0);
reply.writeNoException();

return true;
}
}

return super.onTransact(code, data, reply, flags);
}

private static class Proxy implements com.tzx.aidldemo.aidl.IBookManager {
private android.os.IBinder mRemote;

Proxy(android.os.IBinder remote) {
mRemote = remote;
}

@Override
public android.os.IBinder asBinder() {
return mRemote;
}

public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}

@Override
public java.util.List<com.tzx.aidldemo.aidl.Book> getBookList()
throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List<com.tzx.aidldemo.aidl.Book> _result;

try {
_data.writeInterfaceToken(DESCRIPTOR);
//调用远程服务addBook()
mRemote.transact(Stub.TRANSACTION_getBookList, _data,
_reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.tzx.aidldemo.aidl.Book.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}

return _result;
}

@Override
public void addBook(com.tzx.aidldemo.aidl.Book book)
throws android.os.RemoteException {

android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();

try {
_data.writeInterfaceToken(DESCRIPTOR);

if ((book != null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
//调用远程服务addBook
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
}
}

用关系图表示比较清楚些。。

IBookManager.java

每个文件结构我们都解析完了,那么aidl到底是怎么实现通信的呢,要让我们自己写一套类似于aidl的那么应该怎么去设计呢?

我们仿aidl画一幅结构图:
AIDL

根据上面这个图,我们就可以写出自己的aidl。

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
//方法接口
public interface IBookManager {
final int CAHAGE_MSG = 1;
Book change(Book book);
}
//实现方法的代理类
public class Proxy implements IBookManager{
private static IBinder mRemote;
public static Proxy asInterface(IBinder service) {
mRemote = service;
return new Proxy();
}

public Book change(Book book) {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
try {
data.writeInt(1);
book.writeToParcel(data, 0);
mRemote.transact(IBookManager.CAHAGE_MSG, data, reply, 0);
reply.readException();
if(0 != reply.readInt()) {
return Book.CREATOR.createFromParcel(reply);
}
} catch (RemoteException e) {
e.printStackTrace();
}finally {
data.recycle();
reply.recycle();
}
return null;
}
}
//Binder远端实现类
public class Stub extends Binder implements IBookManager {
@Override
public Book change(Book book) {
book.bookName = "Server";
return book;
}

@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code) {
case IBookManager.CAHAGE_MSG:
Book book = null;
if (0 != data.readInt()) {
book = Book.CREATOR.createFromParcel(data);
}
book = change(book);
reply.writeNoException();
reply.writeInt(1);
book.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
reply.writeParcelable(book, 0);
return true;
}
return super.onTransact(code, data, reply, flags);
}
}

看完以上针对aidl的文字和图片结合方式讲解我想你应该能熟练的开发aidl了吧,如果还有问题可以给我留言哦~!

GitHubDemo地址

想阅读作者的更多文章,可以查看我的公共号:

振兴书城
文章目录
  1. 1. 概述
  2. 2. 语法
  3. 3. 使用AIDL实现IPC
    1. 3.1. 实现步骤 (官网AIDL样例)
    2. 3.2. 创建一个Book.aidl文件
    3. 3.3. 在Book.aidl的包下创建Book.java类文件
    4. 3.4. 创建aidl接口文件IBookManager.aidl
    5. 3.5. 服务端:
    6. 3.6. 客户端:
    7. 3.7. 运行结果
    8. 3.8. 解析aidl生成的java类
,