IPC详解之Binder工作原理（中）

2016-07-12 本文已影响583人 HVCKER

Binder是Android中的一个类，她实现了IBinder接口。从IPC角度来说，Binder是客户端和服务端进行通讯的媒介！（PS：在Android系统有两个不同的进程，请求数据的进程为客户端，接收请求的进程为服务端）

Service与Binder之间的关系

Android开发中，Binder主要用在Service：

同一个进程bindService
Messenger发送Message
通过AIDL跨进程bindService

第一种bindService在ServiceConnection中的onServiceConnected(ComponentName name, IBinder service)的service是绑定的Service自身，这就可以直接调用Service中的方法，没有涉及Binder核心功能。第二种Messenger发送Message底层其实是封装AIDL，所以我们用AIDL来分析Binder的工作原理。

AIDL进行IPC

创建AIDL文件
- User.aidl
```
package com.hk.b.aidl;
parcelable User;
```
由于User类无法在AIDL中直接使用，所以要创建User.aidl对User.java进行描述
- IUserManager.aidl
```
package com.hk.b.aidl;
import com.hk.b.aidl.User;

interface IUserManager {
    List<User> getUserList();
    void addUser(in User u);
}
```
AIDL不同于Java，即使两个aidl文件处于同一个包下，也要对引用进行import

2.使用.aidl文件生成的.java文件
定义好aidl文件后，系统会自动在Android Studio的ProjectName/ModuleName/build/generated/source/com.hk.b.aidl/IUserManager.java,可以直接在Service中使用这个类，这个类的内容是Binder原理的关键，稍后解析。

public class UserService extends Service {

    private CopyOnWriteArrayList<User> mUserList = new CopyOnWriteArrayList<>();

    public UserService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }


    private IBinder mBinder = new IUserManager.Stub() {
        @Override
        public List<User> getUserList() throws RemoteException {
            Log.d("hvcker","server getUsers");
            return mUserList;
        }

        @Override
        public void addUser(User u) throws RemoteException {
            Log.d("hvcker","server add");
            mUserList.add(u);
        }
    };
}

另外这个Service在AndroidManifest.xml文件中要配置使该Service运行在新的进程中，这样才能达到IPC

<service android:name=".s.UserService" android:process=":remote"/>

3.客户端绑定服务端

定义一个IUserManager变量

private IUserManager mUserManager;
```

定义一个ServiceConnection

private ServiceConnection mConn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mUserManager = IUserManager.Stub.asInterface(service);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        mUserManager = null;
    }
};

绑定Service

bindService(new Intent(this, UserService.class), mConn, BIND_AUTO_CREATE);

这个时候就可以用mUserManager来执行addUser和getUserList，那么问题来了，mUserManager是怎么把客户端的数据添加到服务端，又是怎么获取服务端的数据呢？

Binder工作原理

首先，我们来看一下根据IUserManager.aidl文件生成的Java类中有什么乾坤
1.先来大概看一下IUserManager.java

public interface IUserManager extends android.os.IInterface {
    public static abstract class Stub extends android.os.Binder implements com.hk.b.aidl.IUserManager {
    //...
    }
    public java.util.List<com.hk.b.aidl.User> getUserList() throws android.os.RemoteException;

    public void addUser(com.hk.b.aidl.User u) throws android.os.RemoteException;
}

IUserManager继承IInterface这个接口，要想在Binder中用，这是必须的。
内部类Stub继承Binder,同时它又实现了IUserManager。Stub他是一个抽象类，是因为它没有实现IUserManager的未实现方法，这两个方法要在使用该Stub的时候实现。

2.再来看一下IUserManager.Stub

public static abstract class Stub extends android.os.Binder implements com.hk.b.aidl.IUserManager {
    private static final java.lang.String DESCRIPTOR = "com.hk.b.aidl.IUserManager";

    public Stub() {
        this.attachInterface(this, DESCRIPTOR);
    }

    public static com.hk.b.aidl.IUserManager asInterface(android.os.IBinder obj) {
        if ((obj == null)) {
            return null;
        }
        android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (((iin != null) && (iin instanceof com.hk.b.aidl.IUserManager))) {
            return ((com.hk.b.aidl.IUserManager) iin);
        }
        return new com.hk.b.aidl.IUserManager.Stub.Proxy(obj);
    }

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

    @Override
    public boolean onTransact(int code, android.os.Parcel data, 
        //...
        return super.onTransact(code, data, reply, flags);
    }

    private static class Proxy implements com.hk.b.aidl.IUserManager {
        //...
    }
    //...
}

DESCRIPTOR:Binder的唯一标识，一般用当前aidl生成类的类名表示，例如：com.hk.b.aidl.IUserManager
Stub():构造函数，把该接口添加到本地接口中
asBinder():返回当前Binder对象
asInterface(android.os.IBinder obj):android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);客户端查询本地接口，如果本地接口有，说明客户端和服务端是属于同一个进程，则返回该进程里的IInterface，如果没有说明客户端和服务端不属于同一个进程，则new com.hk.b.aidl.IUserManager.Stub.Proxy(obj),返回Binder代理类Sub.Proxy,Binder跨进程的关键来了

3.IUserManager.Stub.Proxy和它用到的一些Stub成员或方法

public static abstract class Stub extends android.os.Binder implements com.hk.b.aidl.IUserManager {
    
    //...
    
    @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_getUserList: {
                data.enforceInterface(DESCRIPTOR);
                java.util.List<com.hk.b.aidl.User> _result = this.getUserList();
                reply.writeNoException();
                reply.writeTypedList(_result);
                return true;
            }
            case TRANSACTION_addUser: {
                data.enforceInterface(DESCRIPTOR);
                com.hk.b.aidl.User _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = com.hk.b.aidl.User.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.addUser(_arg0);
                reply.writeNoException();
                return true;
            }
        }
        return super.onTransact(code, data, reply, flags);
    }

    private static class Proxy implements com.hk.b.aidl.IUserManager {
        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.hk.b.aidl.User> getUserList() throws android.os.RemoteException {
            android.os.Parcel _data = android.os.Parcel.obtain();
            android.os.Parcel _reply = android.os.Parcel.obtain();
            java.util.List<com.hk.b.aidl.User> _result;
            try {
                _data.writeInterfaceToken(DESCRIPTOR);
                mRemote.transact(Stub.TRANSACTION_getUserList, _data, _reply, 0);
                _reply.readException();
                _result = _reply.createTypedArrayList(com.hk.b.aidl.User.CREATOR);
            } finally {
                _reply.recycle();
                _data.recycle();
            }
            return _result;
        }

        @Override
        public void addUser(com.hk.b.aidl.User u) 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 ((u != null)) {
                    _data.writeInt(1);
                    u.writeToParcel(_data, 0);
                } else {
                    _data.writeInt(0);
                }
                mRemote.transact(Stub.TRANSACTION_addUser, _data, _reply, 0);
                _reply.readException();
            } finally {
                _reply.recycle();
                _data.recycle();
            }
        }
    }

    static final int TRANSACTION_getUserList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_addUser = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}

TRANSACTION_getUserList和TRANSACTION_addUser接口方法id，如果有更多方法，依次递增
Proxy实现了IUserManager，并实现了它的两个方法getUserList()，addUser(com.hk.b.aidl.User u)，这两个方法是在客户端执行的，做了什么事呢？
1. 创建android.os.Parcel类型的_data和_replay，_data用来存放方法参数，_replay用来存放RPC的返回值。
2. _data.writeInterfaceToken(DESCRIPTOR)写入唯一标识，如果方法有参数，写入1，然后把参数信息写入_data
3. mRemote.transact(Stub.TRANSACTION_xxx, _data, _reply, 0)Binder发起RPC,传入方法id,参数，返回值和标志位，0表示普通RPC
4. _result = _reply.createTypedArrayList(com.hk.b.aidl.User.CREATOR)如果方法有返回值的话，_reply调用.createXxx()方法，Xxx表示返回值类型，比如TypedArrayList返回的类型是带泛型的ArrayList
5. 最后回收_data和_reply避免资源的浪费
一旦客户端执行transact，客户端发起RPC的线程就会挂起，等待服务端的响应，这个时候就会调用服务端Stub的onTransact方法，这个方法又干了什么呢？
1. 匹配方法id，不用多说
2. 从服务端Binder线程池中用唯一标示符匹配客户端传过来android.os.Parcel类型的data和reply，如果data.readInt()不为0，取出参数
3. 调用与客户端请求对应的服务端实现IUserManager的方法
4. 如果方法有返回值，则写入reply
5. 返回true，如果返回false，则服务端拒绝，可以用这个来做权限判断。

总结

这样我们就很清晰的知道了Binder的工作原理，我们完全可以不用aidl文件自己写一个Binder，但是存在即是合理，还是要用aidl文件来节约开发成本，最后来画一下Binder的流程图吧

Client->Server: bindService
Server-->Client: 返回一个Binder
Client->Server: Binder请求数据，写入参数，调用transact，挂起
Note right of Server:onTransact从Binder线程池中得到与客户端对应的Binder，处理请求
Server-->Client: 写入结果，返回给客户端Binder，并唤醒客户端

IPC详解之Binder工作原理（中）

Service与Binder之间的关系

AIDL进行IPC

Binder工作原理

总结

猜你喜欢

热点阅读