Android中的IPC方式——Binder（一）
在开发过程中，实现进程间通信用的最多的就是 AIDL。
AIDL(Android Interface Definition Language)，也就是接口定义语言，提供接口给远程调用者。
当我们定义好 AIDL 文件，在编译时编译器会帮我们生成代码实现 IPC 通信。为了可以更好的理解Binder的过程，从AIDL入手。
服务端
先创建一个服务端，创建一个IStudentManager.aidl文件,声明2个方法getStudentList()以及addStudent()
IStudentManager.aidl
// IStudentManager.aidl
package com.golden.aidlserver;
import com.golden.aidlserver.Student;
// Declare any non-default types here with import statements
interface IStudentManager {
List getStudentList();
void addStudent(in Student student);
}
IStudentManager.java
Build一下工程，android studio会自动为我们生成一个java类：IStudentManager.java,大体结构如下。
package com.golden.aidlserver;
// Declare any non-default types here with import statements
public interface IStudentManager extends android.os.IInterface {
public static abstract class Stub extends android.os.Binder
implements com.golden.aidlserver.IStudentManager {
private static final java.lang.String DESCRIPTOR = "com.golden.aidlserver.IStudentManager";
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
public static com.golden.aidlserver.IStudentManager asInterface(android.os.IBinder 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 {...}
private static class Proxy implements com.golden.aidlserver.IStudentManager {
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 getStudentList() throws android.os.RemoteException {...}
@Override
public void addStudent(com.golden.aidlserver.Student student) throws android.os.RemoteException {...}
static final int TRANSACTION_getStudentList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addStudent = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public java.util.List getStudentList() throws android.os.RemoteException;
public void addStudent(com.golden.aidlserver.Student student) throws android.os.RemoteException;
}
该类首先包含了一个抽象内部类：Stub, 该类继承自Binder并实现了IStudentManager接口。在Stub的内部，又包含了一个静态内部类：Proxy，Proxy类同样实现了IStudentManager接口。
Sercvice
接下来创建一个StudentManagerService,需要实现刚刚我们定义的两个方法,并且在AndroidManifest注册。
public class StudentManagerService extends Service {
private CopyOnWriteArrayList mStudentList = new CopyOnWriteArrayList<>();
@Override
public void onCreate() {
super.onCreate();
mStudentList.add(1,"张三");
}
@Override
public IBinder onBind(Intent intent) {
return new MyBinder();
}
class MyBinder extends IStudentManager.Stub {
@Override
public List getStudentList() throws RemoteException {
return mStudentList;
}
@Override
public void addStudent(Student student) throws RemoteException {
mStudentList.add(student);
}
}
}
客户端
为了逻辑上区分清晰，另外重新创建一个客户端的应用。需要将服务端的aidl以及Student.java拷贝到客户端注意与服务端的包名保持一致
client项目结构
public class ClientMainActivity extends AppCompatActivity {
private static final String TAG = "AIDL Client";
private IStudentManager mRemoteStudentManager;
private int size = 1;
private Button mAddBtn;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mAddBtn = findViewById(R.id.mButton);
Intent intent = new Intent();
intent.setComponent(new ComponentName("com.golden.aidlserver", "com.golden.aidlserver.StudentManagerService"));
bindService(intent, mConnection, BIND_AUTO_CREATE);
initView();
}
private void initView() {
mAddBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
try {
if (mRemoteStudentManager != null) {
mRemoteStudentManager.addStudent(new Student(size+1,"李四"+String.valueOf(size+1)));
List studentList = mRemoteStudentManager.getStudentList();
size = studentList.size();
Log.e(TAG,studentList.toString());
}
} catch (RemoteException e) {
e.printStackTrace();
}
}
});
}
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.e(TAG, "onServiceConnected");
//获得IStudentManager对象
mRemoteStudentManager = IStudentManager.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e(TAG, "onServiceDisconnected");
mRemoteStudentManager = null;
}
};
}
client中去bindservice在onServiceConnected()中得到服务端获得IStudentManager对象mRemoteStudentManager,可以通过mRemoteStudentManager来调用服务端service的方法。实现点击button之后服务端添加一个学生然后getStudentList()打印出来。
image
Stub
public static abstract class Stub extends android.os.Binder implements com.golden.aidlserver.IStudentManager {
private static final java.lang.String DESCRIPTOR = "com.golden.aidlserver.IStudentManager";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.golden.aidlserver.IStudentManager interface,
* generating a proxy if needed.
*/
public static com.golden.aidlserver.IStudentManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.golden.aidlserver.IStudentManager))) {
return ((com.golden.aidlserver.IStudentManager) iin);
}
return new com.golden.aidlserver.IStudentManager.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 {
java.lang.String descriptor = DESCRIPTOR;
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(descriptor);
return true;
}
case TRANSACTION_getStudentList: {
data.enforceInterface(descriptor);
java.util.List _result = this.getStudentList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addStudent: {
data.enforceInterface(descriptor);
com.golden.aidlserver.Student _arg0;
if ((0 != data.readInt())) {
_arg0 = com.golden.aidlserver.Student.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addStudent(_arg0);
reply.writeNoException();
return true;
}
default: {
return super.onTransact(code, data, reply, flags);
}
}
static final int TRANSACTION_getStudentList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addStudent = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
stub结构
其中有一个DESCRIPTOR，它在Stub初始化的时候会绑定这个标识符，就是前面曾经提到的安全性方面。
client与server拥有一样的IStudentManager.java文件,在client端我们可以看到
//client端
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.e(TAG, "onServiceConnected");
//获得IStudentManager对象
mRemoteStudentManager = IStudentManager.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e(TAG, "onServiceDisconnected");
mRemoteStudentManager = null;
}
};
我们在 client端中bindservice中在onServiceConnected()会传给我们一个IBinder，这个 IBinder类型的参数是Binder驱动传给我们的，后面在framework的会说到。方法中会去调用 binder.queryLocalInterface() 去查找 Binder 本地对象，如果找到了就说明 Client 和 Server 在同一进程，那么这个 binder 本身就是 Binder 本地对象，可以直接使用。否则说明是 IBinder是个远程对象，也就是 BinderProxy。因此需要我们创建一个代理对象 Proxy，通过这个代理对象来是实现远程访问。
server端中我们只是创建了stub的对象并且实现了其中定义的两个方法，等待调用onTransact()方法。
//server端
class MyBinder extends IStudentManager.Stub {
@Override
public List getStudentList() throws RemoteException {
return mStudentList;
}
@Override
public void addStudent(Student student) throws RemoteException {
mStudentList.add(student);
}
}
Proxy
在client中当client 和server处于不同的进程的情况下，client使用的是Proxy对象mRemote。
private static class Proxy implements com.golden.aidlserver.IStudentManager {
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 getStudentList() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getStudentList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.golden.aidlserver.Student.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void addStudent(com.golden.aidlserver.Student student) 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 ((student != null)) {
_data.writeInt(1);
student.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addStudent, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
单独看下 client调用getStudentList()过程就是 proxy中调用。数据包_data需要将标识符DESCRIPTOR写入，远程调用mRemote.transact(Stub.TRANSACTION_getStudentList, _data, _reply, 0);（因性能考虑需要将方法以int值来标识），然后server端会调用到stub中的ontranscat()，最后client中的proxy得到结果。
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply,
int flags) throws android.os.RemoteException {
java.lang.String descriptor = DESCRIPTOR;
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(descriptor);
return true;
}
case TRANSACTION_getStudentList: {
data.enforceInterface(descriptor);
java.util.List _result = this.getStudentList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addStudent: {
data.enforceInterface(descriptor);
com.golden.aidlserver.Student _arg0;
if ((0 != data.readInt())) {
_arg0 = com.golden.aidlserver.Student.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addStudent(_arg0);
reply.writeNoException();
return true;
}
default: {
return super.onTransact(code, data, reply, flags);
}
}
}
将_result 写入 _replay中返回给客户端。如果是在同一个进程中，就将直接调用stub中的getStudent()方法不会走transact()和onTransact()逻辑。
image
以上就是一个简单的进程通信的流程，在不同进程的前提下，在理解的时候可以把client的所有操作都是通过proxy来实现，server端就是stub的具体实现。
下一篇会讲framework层源码。