在认识IPC（Inter-Process Communication，进程间通信）之前，肯定要先理解什么是线程，什么是进程？在多数操作系统中，线程是最小的可操作调度单元。而进程一般则是一个具体的应用（比如QQ、微信），其可以包含有多个线程。要在不同的进程进行数据的传输与通信，就需要用到IPC机制了。
在Android中跨进程通信的方式有很多，如intent传递、读写文件、socket通信、SharedPreferences(不可靠)、ContentProvider以及Binder等。本文主要讲解Binder机制的用法及其简单原理，这次的demo是客户端跨进程请求服务端返回一个我们需要的int值，效果如下：
简单来说Binder是Android系统为我们提供的一个用于进程通信的类，我们一般通过AIDL语言自动让ide工具为我们生成（如果你不嫌累不嫌头疼完全可以自己写），其结构类似这样：
package com.example.lucky.aidl;
// Declare any non-default types here with import statements
public interface IMyAidlInterface extends android.os.IInterface
{
public int plusResult(int a, int b) throws android.os.RemoteException;
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.example.lucky.aidl.IMyAidlInterface
{
private static final java.lang.String DESCRIPTOR = "com.example.lucky.aidl.IMyAidlInterface";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.example.lucky.aidl.IMyAidlInterface interface,
* generating a proxy if needed.
*/
public static com.example.lucky.aidl.IMyAidlInterface asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.lucky.aidl.IMyAidlInterface))) {
return ((com.example.lucky.aidl.IMyAidlInterface)iin);
}
return new com.example.lucky.aidl.IMyAidlInterface.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
{
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.example.lucky.aidl.IMyAidlInterface
{
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 int plusResult(int a, int b) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(a);
_data.writeInt(b);
mRemote.transact(Stub.TRANSACTION_plusResult, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
static final int TRANSACTION_plusResult = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
}
乍一看代码很杂乱，逻辑也很复杂，其实对于我们这样的萌新只需要理解清这个接口的内部类Stub、内部类中的asInterface(android.os.IBinder obj)、onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)、以及Proxy就可以简单使用Binder了。下面我会逐一分析这些。
Stub
这个Stub就是我们需要的Binder类了，当我们在客户端bindService时会通过远程服务端的onBinder方法中会return 给我们.
@Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
return mBinder;
}
通过这个Binder类，我们可以就在客户端取得 他的内部类Proxy，从而在客户端完成相应操作。
asInterface(android.os.IBinder obj)
通过此方法我们可以将服务端生成的Binder对象（Stub）转化成AIDL接口型的对象。需要注意的是此方法是区分进程的，如果客户端和服务端处于同一进程，则不会进行转换，直接把Stub返回给客户端，当处于不同进程时，会返回Stub.Proxy对象。
public static com.example.lucky.aidl.IMyAidlInterface asInterface(android.os.IBinder obj){
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.lucky.aidl.IMyAidlInterface))) {
return ((com.example.lucky.aidl.IMyAidlInterface)iin);
}
return new com.example.lucky.aidl.IMyAidlInterface.Stub.Proxy(obj);
}
onTransact
此方法运行在服务端的Binder线程池中，当我们在客户端远程请求服务端的方法时，就会执行该方法。我们可以发现它就收的参数类型int code, android.os.Parcel data, android.os.Parcel reply, int flags都是可序列化的Parcel 型，这点后面会讲。基本原理就是服务端通过data取出客户端传入的参数，然后写入reply返回给客户端。
Proxy
Proxy可以直译为代理人，从名字上我们就能看出这是服务端返回给我们的Binder的一个代理人（为了与时俱进，我们可以把它称作经纪人~），通过它我们可以在客户端远程调用服务端的方法。注意此时会挂起客户端的当前线程，直到服务器返回数据成功，所以如果我们直接在此处更新UI是很容易引起ANR让我们的应用挂掉（因为等待服务器一般都比较耗时）！为了避免ANR，常用的方法就是新建线程通过判断返回的Proxy是否为null来请求服务端。
通过上面的分析我们应该对Binder的工作流程有了一定的了解，接下来就通过demo代码，更直观地学会如何使用Binder进行进程间通信。
Demo创建流程
- 1 创建AIDL接口
// IMyAidlInterface.aidl
package com.example.lucky.aidl;
// Declare any non-default types here with import statements
interface IMyAidlInterface {
int plusResult(in int a, in int b);
}
这儿只声明了一个方法plusResult，往后看就会发现，通过AIDL暴露出来的方法会在Service端实现，从而让客户端调用。这儿我们只关心AIDL文件中支持的数据类型：java基本数据类型、ArrayList(里面元素也必须支持AIDL)、HashMap(里面元素也必须支持AIDL)、所有可序列化的自定义对象（实现了Parcelable接口）。这儿我们的plusResult方法中接收的参数是最简单的int型，如果是自定义的Parcel对象，我们还需要额外创建AIDL文件声明该对象。例：
int plusResult(in int a, in User use);
我们必须在同目录下声明该User对象：
// IMyAidlInterface.aidl
package com.example.lucky.aidl;
parcelable User;
参数名前面的in、out分别表示输入、输出型参数。
- 2 创建远程服务端
此例的Service为了额外创建新的工程直接通过android:process=".anotherProcess"属性将其进程定义为了其他线程。
public class PlusService extends Service {
private Binder mBinder;
@Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
return mBinder;
}
@Override
public void onCreate() {
super.onCreate();
mBinder = new IMyAidlInterface.Stub() {
@Override
public int plusResult(int a, int b) throws RemoteException {
/*try {
new Thread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
return a+b;
}
};
}
}
代码十分简单，主要在onCreate时实例化 了IMyAidlInterface.Stub，在其中实现了客户端请求的plusResult方法，然后通过onBind传递出去。
- 3 客户端bindService进行远程请求
public class MainActivity extends AppCompatActivity {
private ServiceConnection mServiceConnection;
private int plusResult;
@InjectView(R.id.firstEditText)
EditText firstEditText;
@InjectView(R.id.secondEditText)
EditText secondEditText;
@InjectView(R.id.result)
TextView result;
@InjectView(R.id.mButton)
Button mButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.inject(this);
mButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if ((firstEditText.getText().length()==0) || (secondEditText.getText().length()==0)) {
Toast.makeText(MainActivity.this,"请输入数字",Toast.LENGTH_LONG).show();
return;
} else {
final int a = Integer.valueOf(firstEditText.getText().toString().trim());
final int b = Integer.valueOf(secondEditText.getText().toString().trim());
mServiceConnection = new ServiceConnection() {
//onServiceConnected onServiceDisconnected都是在UI线程中进行的，所以当需要耗时操作时，可以通过判断bookManager（proxy）对象是否为空，在子线程中进行
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
IMyAidlInterface myAidlInterface = IMyAidlInterface.Stub.asInterface(iBinder);
try {
plusResult = myAidlInterface.plusResult(a,b);
result.setText(" "+plusResult);
Toast.makeText(MainActivity.this,"服务器响应拉，亲～",Toast.LENGTH_LONG).show();
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
}
};
Intent intent = new Intent(MainActivity.this,PlusService.class);
if (mServiceConnection != null) {
bindService(intent,mServiceConnection, Context.BIND_AUTO_CREATE);
}
}
}
});
}
@Override
protected void onDestroy() {
if (mServiceConnection != null) {
unbindService(mServiceConnection);
}
super.onDestroy();
}
}
在ServiceConnection 的onServiceConnected回调方法中我们获得了我们想要的经纪人IMyAidlInterface myAidlInterface = IMyAidlInterface.Stub.asInterface(iBinder);,通过它就可以远程请求服务端的方法了，这儿为了代码简洁没有新建线程处理，其实只要在服务端sleep一下，客户的程序就很容易ANR挂掉了，有兴趣的同学可以自己尝试一下。最后千万别忘记在客户端unbindService，这样一个简单的跨进程通信demo就创建好了~
总结下使用AIDL时的那些坑：
- 客户端、服务端所有AIDL文件的packagename必须手动修改为相同的
- 远程服务端需要通过
android:exported="true"属性暴露出来 - 有时候找不到系统自动生成的Binder类，我们需要remake一下这个工程
- 自定义创建的对象一定要实现Parcelable且额外声明
- AIDL即使在相同package内，也要手动导包
。。。。。。
网友评论