Android Binder机制

约定不等于承诺〃 2022-05-29 07:19 225阅读 0赞

本篇博客参考资料：  
《Android开发艺术探索》——任玉刚  
[简单明了，彻底地理解Binder][Binder]

Binder是Android一个非常重要的类，它实现了IBinder接口。从IPC角度来说，Binder是Android中的一种跨进程通信方式；从Android Framework角度来说，Binder是ServiceManager连接各种Manager（ActivityManager、WindowManager等）和相应ManagerService的桥梁；从Android Application角度来说，Binder是客户端和服务端进行通信的媒介。——《Android开发艺术探索》

为了方便之后的理解，先贴上一段AIDL的java代码，这就是我之前写的AIDL博客中的demo：

public interface IMyAidlInterface extends android.os.IInterface {
        
        /**
         * Local-side IPC implementation stub class.
         */
        public static abstract class Stub extends android.os.Binder implements com.example.xwx.servicedemo.IMyAidlInterface {
        
            private static final java.lang.String DESCRIPTOR = "com.example.xwx.servicedemo.IMyAidlInterface";
    
            /**
             * Construct the stub at attach it to the interface.
             */
            public Stub() {
                this.attachInterface(this, DESCRIPTOR);
            }
    
            /**
             * Cast an IBinder object into an com.example.xwx.servicedemo.IMyAidlInterface interface,
             * generating a proxy if needed.
             */
            public static com.example.xwx.servicedemo.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.xwx.servicedemo.IMyAidlInterface))) {
                    return ((com.example.xwx.servicedemo.IMyAidlInterface) iin);
                }
                return new com.example.xwx.servicedemo.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 {
                switch (code) {
                    case INTERFACE_TRANSACTION: {
                        reply.writeString(DESCRIPTOR);
                        return true;
                    }
                    case TRANSACTION_basicTypes: {
                        data.enforceInterface(DESCRIPTOR);
                        int _arg0;
                        _arg0 = data.readInt();
                        long _arg1;
                        _arg1 = data.readLong();
                        boolean _arg2;
                        _arg2 = (0 != data.readInt());
                        float _arg3;
                        _arg3 = data.readFloat();
                        double _arg4;
                        _arg4 = data.readDouble();
                        java.lang.String _arg5;
                        _arg5 = data.readString();
                        this.basicTypes(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);
                        reply.writeNoException();
                        return true;
                    }
                    case TRANSACTION_showProcess: {
                        data.enforceInterface(DESCRIPTOR);
                        this.showProcess();
                        reply.writeNoException();
                        return true;
                    }
                }
                return super.onTransact(code, data, reply, flags);
            }
    
            private static class Proxy implements com.example.xwx.servicedemo.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 void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException {
                    android.os.Parcel _data = android.os.Parcel.obtain();
                    android.os.Parcel _reply = android.os.Parcel.obtain();
                    try {
                        _data.writeInterfaceToken(DESCRIPTOR);
                        _data.writeInt(anInt);
                        _data.writeLong(aLong);
                        _data.writeInt(((aBoolean) ? (1) : (0)));
                        _data.writeFloat(aFloat);
                        _data.writeDouble(aDouble);
                        _data.writeString(aString);
                        mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);
                        _reply.readException();
                    } finally {
                        _reply.recycle();
                        _data.recycle();
                    }
                }
    //定义自己需要的方法
    //显示当前服务的进度
    
                @Override
                public void showProcess() throws android.os.RemoteException {
                    android.os.Parcel _data = android.os.Parcel.obtain();
                    android.os.Parcel _reply = android.os.Parcel.obtain();
                    try {
                        _data.writeInterfaceToken(DESCRIPTOR);
                        mRemote.transact(Stub.TRANSACTION_showProcess, _data, _reply, 0);
                        _reply.readException();
                    } finally {
                        _reply.recycle();
                        _data.recycle();
                    }
                }
            }
    
            static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
            static final int TRANSACTION_showProcess = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
        }
    
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException;
    //定义自己需要的方法
    //显示当前服务的进度
    
        public void showProcess() throws android.os.RemoteException;
    }

到底如何理解Binder呢？我们可以思考几个问题，如果Android开发团队需要实现进程之间的通信，那么他们必须解决下面三个问题：

*  如何知道客户端需要调用哪个进程以及该进程中的方法
 *  客户端如何将函数形参发送给远程进程中的方法，以及如何将远程进程中的方法执行结果返回客户端
 *  如何去屏蔽底层通信细节，让实现客户端调用远程方法就像调用本地方法一样

第一个问题的解决方法：给需要远程通信的类唯一标识，这可以通过包名+类名的方式做到，之后为类中的每一个方法编号即可。

第二个问题的解决方法：利用Parcelable接口，这个接口提供2个重要函数，分别是将对象中的属性写入到数组和从数组中的数据还原对象，每个可以发送到远程方法作为形参的对象只需实现Parcelable对象即可。

但是第三个问题如何解决？Android团队为了封装这些通信细节，必须要设置一个类，在这个类的内部实现这些细节。这个类得帮用户发送远程请求并将返回结果提交给用户，这个类就是Binder。

Binder类既然封装很多功能，那该怎么用这个类呢？让客户端去继承还是服务端继承呢？答案是服务端。接下来有个约定，本文后面所指的Binder类都是指远程服务端的对象。服务端想要实现被跨进程访问，就必须继承Binder类。

首先我们看看我们的程序跨进程调用系统服务的简单示例，实现浮动窗口部分代码：

//获取WindowManager服务引用
    WindowManager wm = (WindowManager)getSystemService(getApplication().WINDOW_SERVICE);  
    //布局参数layoutParams相关设置略...
    View view=LayoutInflater.from(getApplication()).inflate(R.layout.float_layout, null);  
    //添加view
    wm.addView(view, layoutParams);

系统服务都是运行在systemServer进程中，因此我们调用系统服务都是跨进程的调用。第2行代码中，得到的wm是WindowManager对象的引用，第6行调用WindowManager的addView函数，将触发远程调用，调用的是运行在systemServer进程中的WindowManager的addView函数。是不是很想知道addView发生了什么？我们先看看Binder机制吧！看完Binder原理，再解释！

#### Binder机制 ####

##### 执行过程 #####

假设你已经创建好服务端类MyService、客户端类MyClient（服务端和客户端在不同进程下）。在客户端持有MyService的引用，并且调用了MyService的func函数，那么Android内部调用过程如下：  
![这里写图片描述][Image 1]

用文字描述的话，整个过程大概是这样的：客户端首先利用Parcel将相关数据传给Binder驱动，此时客户端的线程将会挂起；客户端要调用的目标方法是在Stub类中的内部类Proxy里，Proxy里面的方法运行在客户端，当客户端远程调用Proxy中对应的方法时，首先会创建该方法所需要的输入型Parcel对象\_data，输出型Parcel对象\_reply和返回值对象List，接着调用transact()方法这个发起跨进程请求，同时将客户端当前线程挂起；而请求将会交给Binder下的`onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)`方法处理，服务端将会根据code参数判断客户端请求调用的方法是什么，接着从data中取出目标方法锁需要的参数，然后执行目标方法，当方法执行完毕后，就向reply中写入方法的返回值，如果onTransact方法返回false，那么表示客户端请求调用服务端的方法失败。

看了这个图以后，相信你对你的代码在调用远程进程函数时有个全局的认识。这张图有一点很重要，就是客户端当前线程会被挂起！因此，如果远程进程是执行长时间的运算，请不要使用主线程去调用远程函数，以防止ANR。

##### Binder的C/S架构 #####

上面一节我们对远程进程调用代码执行过程有个初步了解，在Android开发中，我们大量使用到了系统Service，比如媒体播放、各种传感器以及WindowManagerService等等等等（太多了~）。那么Android是怎么管理这些服务，并且让用户跨进程调用这些服务呢？首先我们看看调用系统服务的过程。在Android开机启动过程中，Android会初始化系统的各种Service，并将这些Service向ServiceManager注册（即让ServiceManager管理）。客户端想要得到具体的Service直接向ServiceManager要即可。客户端首先向ServiceManager查询得到具体的Service引用，然后通过这个引用向具体的服务端发送请求，服务端执行完成后就返回。

![20160526102248373][]

##### Binder的驱动实现原理 #####

一直以来，我有个困惑！！！这个困惑让我迷茫了很久：客户端持有远程进程的某个对象引用，然后调用引用类中的函数，远程进程的函数就执行了。我在想，凭什么？学过操作系统都知道，不同的进程之间是不共享资源的。也就是说，客户端持有的这个对象跟远程进程中的实际对象完全是两个不同的对象。客户端调用引用的对象跟远程进程半毛钱关系都没有，凭啥远程进程就调用了执行了？相信也有一部分人跟我有同样的困惑！仔细研读一下下面这张图，相信你会豁然开朗！

![20160526120609901][]

服务端跨进程的类都要继承Binder类。我们所持有的Binder引用(即服务端的类引用)并不是实际真实的远程Binder对象，我们的引用在Binder驱动里还要做一次映射。也就是说，设备驱动根据我们的引用对象找到对应的远程进程。客户端要调用远程对象函数时，只需把数据写入到Parcel，在调用所持有的Binder引用的transact()函数，transact函数执行过程中会把参数、标识符（标记远程对象及其函数）等数据放入到Client的共享内存，Binder驱动从Client的共享内存中读取数据，根据这些数据找到对应的远程进程的共享内存，把数据拷贝到远程进程的共享内存中，并通知远程进程执行onTransact()函数，这个函数也是属于Binder类。远程进程Binder对象执行完成后，将得到的写入自己的共享内存中，Binder驱动再将远程进程的共享内存数据拷贝到客户端的共享内存，并唤醒客户端线程。

##### Binder机制运用 #####

#####  #####

我们再看看Android是怎么运用Binder的。再现前面代码：

这段代码前面已经出现过。`getSystemService(getApplication().WINDOW_SERVICE);`函数内部原理就是向ServiceManager查询标识符为`getApplication().WINDOW_SERVICE`的远程对象的引用。即WindowManager对象的引用，这个引用的真正实现是WindowManager的某个代理。得到这个引用后，在调用addView时，真正的实现是在代理里面，代理把参数打包到Parcel对象中，然后调用transact函数（该函数继承自Binder），再触发Binder驱动的一系列调用过程，在Binder驱动实现原理一节中有具体介绍，忘记了的同学可以返回继续看。关于Binder的代理对象，可以参考AIDL工具生成的代码，这里不再具体介绍。

[Binder]: http://blog.csdn.net/huachao1001/article/details/51504469
[Image 1]: 
[20160526102248373]: /images/20220529/7525838b4c464b5a889bb31c0fe6899b.png
[20160526120609901]: /images/20220529/d7e2d7ae45594385afcb04cb9bb04fec.png