IPC——android进程间通信
最后更新于：2022-04-01 14:26:05
### 一，什么是IPC
IPC:inter-process communication，进程间通信或者跨进程通信。window通过剪贴板，管道等进行进程间通信。Linux通过命名管道，共享内存，信号量等进行进程间通信。android有特色的是Binder。在android进程通信可以有以下方式：aidl,socket通信，使用Bundle，使用contentprovider,使用Messenger，使用文件共享。
### 二，android的序列化
在android中能用于进程间通信的对象必须是序列化的。序列的方式有两种，一种是实现Serializable接口，一种是实现Parcelable。Serializable是java提供的序列化方法，实现很简单，只要一个类实现了它就完成了序列化。可用于将对象序列化到存储设备或序列化后通过网络传输。但它的效率不高，这里重点介绍Parcelable，它是android自己的实现序列化方法，先看实现Parcelable的代码：
只要一个类实现了这个接口，就可以实现序列化并可以通过Intent和Binder传递。要实现以下方法
（1）.writeToParcel(out,flags):实现序列化功能，一系列write。如下
out.writeInt(userId);
out.writeParcelable(book,0);//传另一个序列化类
（2）.CREATOR：反序列化，一系列的read方法：如下
userId = in.readInt();
book = in.readParcelable(Thread.currentThread().getContextClassLoader());
（3）.decribeContents:内容描述，几乎所有情况都返回0.
完整代码如下
~~~
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;
}
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel out, int flags) {
out.writeInt( bookId);
out.writeString( bookName);
}
public static final Parcelable.Creator<Book> CREATOR = new Parcelable.Creator<Book>() {
public Book createFromParcel (Parcel in) {
return new Book(in);
}
public Book[] newArray( int size) {
return new Book[size];
}
};
private Book(Parcel in) {
bookId = in.readInt();
bookName = in.readString();
}
@Override
public String toString() {
return String.format("[bookId:%s, bookName:%s]" , bookId , bookName);
}
}
~~~
系统还提供了一些实现了Parcelable接口的类，如Intent,Bundle,Bitmap.同时List和Map也可以序列化，前提是它们里所有元素都 可以序列化。
Parcelable效率比Serializable高，在内存序列化上用它合适。但在将对象序列化到存储设备或序列化后通过网络传输则建议用Serializable，比较方便。
### 三，Binder的介绍
Binder用于完成进程间的通信（IPC）。Binder是工作在Linux层，属于一个驱动，这个驱动不需要驱动，Binder代码运行在内核态，调用Binder是系统进行调用。
Binder是一种架构，这种架构提供服务端接口，Binder 接口，客户端接口三个模块。一个Binder 服务端就是一个Binder对象，该对象一旦创建，就会启动一个隐藏线程，该线程会接Binder 驱动发送的消息。收到消息会发调用 onTransact()方法，并按照参数执行不同的服务代码，onTransact() 的参数来源是客户端调用 transact()，若transact() 有固定的输入，onTransact()就有固定的输出 。
一个服务端被创建，会创建一个mRemote对象，它的类型也是Binder类，客户端要访问远程时是通过它。它也重载了transact()方法，重载内容如下：
1，以线程消息通信模式，向服务端发送客户端传递过来的参数。
2.挂起当前线程，并等待服务端线程执行完指定服务函数后通知。
3.接收服务端通知并执行客户端线程，并返回到客户端代码区。
它的调用图如下：
接下来我们来看看如何使用它。
新建两个文件Book.aidl,IBookManager.aidl，其中Book.aidl是上面序列化后文件的一个声明，主意名称要和序列化的类的名称一样。内容如下：
~~~
package com.lxj.aidl;
parcelable Book;
~~~
再看下IBookManager.aidl，这个demo主要实现两个方法，所以都需要这此声明：
~~~
package com.lxj.aidl;
import com.lxj.aidl.Book;
interface IBookManager {
List<Book> getBookList();
void addBook(in Book book);
}
~~~
除了基本数据类型外，其它数据类型都要以in out inout来标识，in表示输入，out表示输出，inout即可表示输入也可表示输出。
这时系统会自动生成一个IBookManager.java文件，内容如下：
~~~
package com.lxj.aidl;
public interface IBookManager extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.lxj.aidl.IBookManager
{
private static final java.lang.String DESCRIPTOR = "com.lxj.aidl.IBookManager";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.lxj.aidl.IBookManager interface,
* generating a proxy if needed.
*/
public static com.lxj.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.lxj.aidl.IBookManager))) {
return ((com.lxj.aidl.IBookManager)iin);
}
return new com.lxj.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);
java.util.List<com.lxj.aidl.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook:
{
data.enforceInterface(DESCRIPTOR);
com.lxj.aidl.Book _arg0;
if ((0!=data.readInt())) {
_arg0 = com.lxj.aidl.Book.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.lxj.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.lxj.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.lxj.aidl.Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.lxj.aidl.Book.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override public void addBook(com.lxj.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);
}
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public java.util.List<com.lxj.aidl.Book> getBookList() throws android.os.RemoteException;
public void addBook(com.lxj.aidl.Book book) throws android.os.RemoteException;
}
~~~
asInterface:用于将服务端的Binder对象转换成客户端所需的AIDL对象，同一进程返回的是服务端的Stub,不同进程返回系统封闭后的Stub.proxy对象。
asBinder:用于返回当前 的Binder对象。
onTransact（code,data,reply,flags）:运行在服务端的Binder线程池中，客户端发出的请求会在此处理。code可以确定客户端的请求目标方法是什么，data取出参数，运行完把结果赋给reply。如果返回false，则客户端请求会失败（可用于权限判断）。
getBookList:首先创建输入输出的Parcel对象_data,_reply。接着调用transact方法来发起RPC(远程过程调用)请求，同时挂起线程，然后服务端onTransact会调用，直到RPC执行完，当前线程继续执行，并从_reply取出RPC结果。返回。
### 四，AIDL进程间调用
aidl是最常见的进程调用方式。我们先创建两个应用，模拟进程间通信（不同应用）。客户端的代码如下：
~~~
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent("com.lxj.servicetest.MyAIDLService");
bindService(intent, connection, Context.BIND_AUTO_CREATE);
}
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
IBookManager bookManager = IBookManager.Stub.asInterface(service);
try {
List<Book> list = bookManager.getBookList();
Log.e("list", list.toString());
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
~~~
通过bindService绑定服务端Binder，然后通过IBookManager.Stub.asInterface()来获得服务端返回的AIDL对象，就可以调用到服务端的方法（getBookList）。再看下服务端代码：
~~~
public class MyBookService extends Service {
private CopyOnWriteArrayList<Book> mBooks = new CopyOnWriteArrayList<Book>();
@Override
public void onCreate() {
// TODO Auto-generated method stub
super.onCreate();
mBooks.add(new Book(1,"java虚拟机"));
mBooks.add(new Book(2,"android疯狂讲义"));
}
private Binder mBinder = new IBookManager.Stub() {
//虽然IBinder只能传输List,但是服务端之所以可以用CopyOnWriteArrayList是因为它会自动在传输时转化为list
@Override
public List<Book> getBookList() throws RemoteException {
// TODO Auto-generated method stub
return mBooks;
}
@Override
public void addBook(Book book) throws RemoteException {
// TODO Auto-generated method stub
mBooks.add(book);
}
};
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return mBinder;
}
}
~~~
自定义了一个Service并在list中添加两本书，所以客户端就能在控制台上打印出这两本书。注意要在AndroidFest.xml添加上Service的声明：
~~~
<service
android:name="com.lxj.aidl.MyBookService"
>
<intent-filter>
<action android:name="com.lxj.servicetest.MyAIDLService"/>
</intent-filter>
</service>
~~~
### 五，Messenger进程间通信
android提供Messenger可以实现不同进程间的信息传递，相比AIDL它的调用简单很多，但是它是有缺点的，它只能串行处理发送的信息，如里信息过多就会阻塞。其次它只能传输基本数据类型，What,arg1,Bundle等，并不能传输自定义的对象。Messenger是一种种轻量级的IPC方案，一次处理一个请求。
1.服务端：
创建一个Service来处理客户端连接请求，同时创建一个Handler并通过它来创建一个Message对象，然后在OnBinder中返回这个Binder。
2.客户端：
首先绑定服务端Service，通过返回的IBinder创建一个messager。这个就可以给服务端发消息了，如果需要服务端返回，则也要跟服务端一个创建Handler，通过Message的replyTo参数传递给服务端。
先看下客户端的代码：
先看客户端代码：
~~~
public class MainActivity extends Activity {
TextView txvTextView ;
private Messenger mService;
private Messenger clientMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch(msg.what){
case 1:
Log.e("msg from service", msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
}
}
}
private ServiceConnection connection = new ServiceConnection(){
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// TODO Auto-generated method stub
mService = new Messenger(service);
Message msgMessage = Message.obtain(null,0);
Bundle b = new Bundle();
b.putString("client", "Hi,i am client");
msgMessage.setData(b);
msgMessage.replyTo = clientMessenger;
try {
mService.send(msgMessage);
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
// TODO Auto-generated method stub
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
txvTextView = (TextView)super.findViewById(R.id.txv);
Intent i = new Intent(this,MessengerService.class);
bindService(i, connection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
unbindService(connection);
super.onDestroy();
}
}
~~~
看到上面的代码我们可以很清楚的看到，Messenger也是用AIDL实现进程间通信的。通过Messenger发送消息到服务端，handler中获取服务端返回的replyto。再看下服务端代码：
~~~
public class MessengerService extends Service{
private final Messenger mMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch(msg.what){
case 0:
Log.e("msg from client", msg.getData().getString("client"));
Message message = Message.obtain(null,1);
Messenger messenger = msg.replyTo;//从客户端得到的messenger，用于在客户端中显示
Bundle bundle = new Bundle();
bundle.putString("reply", "Hi,i am service");
message.setData(bundle);
try {
Thread.sleep(1000);
messenger.send(message);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
@Override
public IBinder onBind(Intent intent) {
// TODO Auto-generated method stub
return mMessenger.getBinder();
}
}
~~~
这里就是获取到信息后再把信息发送回客户端。完成了不同进程的信息传递。
这里只是简单介绍两种IPC方式，还有很多常用方式如socket通信，ContentProvider等都可以实现IPC。本文只是总结下自己对IPC的认识。