Binder

Binder
对于Server进程来说，Binder指的是Binder本地对象；
对于Client来说，Binder指的是Binder代理对象
IBinder
IBinder是一个接口，它代表了一种跨进程传输的能力；只要实现了这个接口，就能将这个对象进行跨进程传递；这是驱动底层支持的；在跨进程数据流经驱动的时候，驱动会识别IBinder类型的数据，从而自动完成不同进程Binder本地对象以及Binder代理对象的转换。
IInterface
IInterface代表的就是远程server对象具有什么能力。具体来说，就是aidl里面的接口
BinderProxy
BinderProxy类是Binder类的一个内部类，它代表远程进程的Binder对象的本地代理；这两个类都继承自IBinder, 因而都具有跨进程传输的能力；实际上，在跨越进程的时候，Binder驱动会自动完成Binder和BinderProxy两个对象的转换。
Stub

AIDL实现流程：
首先定一个简单的aidl接口

package com.example.test.app;
interface ICompute {
     int add(int a, int b);
}

自动生成类：

package com.example.test.app;

public interface ICompute extends android.os.IInterface {
   
    public static abstract class Stub extends android.os.Binder implements com.example.test.app.ICompute {
        private static final java.lang.String DESCRIPTOR = "com.example.test.app.ICompute";

        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }
		//通过此方法将IBinder转换为服务接口
        public static com.example.test.app.ICompute asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            //查询本地接口，即是否是服务端自己在调用该接口；
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.example.test.app.ICompute))) {
            	//服务端自己在调用该接口，直接类型强转就可以；
                return ((com.example.test.app.ICompute) iin);
            }
            //其他客户端进程在调用服务接口，返回一个代理对象；
            return new com.example.test.app.ICompute.Stub.Proxy(obj);
        }

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

        @Override		
        //此方法运行在server端，当代理对象发出请求后处理并返回结果
        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_add: {
                    data.enforceInterface(DESCRIPTOR);
                    int _arg0;
                    _arg0 = data.readInt();
                    int _arg1;
                    _arg1 = data.readInt();
                    int _result = this.add(_arg0, _arg1);
                    reply.writeNoException();
                    reply.writeInt(_result);
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.example.test.app.ICompute {
            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	
            //代理对象要做的就是把数据序列化然后发送给server进程
            public int add(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_add, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readInt();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }

        static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    }

    public int add(int a, int b) throws android.os.RemoteException;
}

生成类结构：
1.外层接口：
生成的接口和我们定义的ADIL文件同名，该接口中的方法只有AIDL文件中定义的方法；
并且实现了IInterface，表明这个接口是可以跨进程向其他进程提供AIDL中定义的功能；
2.内部类stub
是一个静态内部抽象类，继承了Binder，实现了外层定义的接口；说明Stub是一个跨进程Server的实体类
3.Stub的内部类Proxy
同样实现了外层接口，为客户端进程提供和stub一样的服务；
持有一个远程的IBinder对象，与server进程交互依赖此IBinder对象；

参考：
Android开发艺术探索
https://link.juejin.im/?target=http%3A%2F%2Fweishu.me%2F2016%2F01%2F12%2Fbinder-index-for-newer%2F