首先要理解Linux中已经存在其他ipc方式，为什么还要使用BInder机制，可以从性能、稳定性、安全性三方面，以下是对比图

image

基础的话就是这张图 说的很明白 唯一需要理解的就是这个mmap 内存映射，简而言之就是将用户空间的一段内存区域映射到内核空间，映射成功后，用户对这段内存区域的修改可以直接反映到内核空间，同样，内核空间对这段区域的修改也直接反映用户空间。那么对于内核空间<---->用户空间两者之间需要大量数据传输等操作的话效率是非常高的。

image

在Android中的ipc存在是非常普遍的

20200405211958344.png

AIDL调用过程的具体流程
首先要知道AIDL是Android Interface Definition Language的缩写，其实就是帮助我们更方便快捷的使用binder的一种工具，使用AIDL系统会帮助我们生成一些代码，简化我们使用binder的成本。以下代码为系统生成的IMyAidlInterface代码，我们详细看下

• 客户端
  首先在调用asInterface方法的时候，会判断一下是否需要的服务是在同一进程 不同进程则返回Proxy

public static com.xxx_service.IMyAidl asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.xxx_service.IMyAidl))) {
                return ((com.xx.leo_service.ILeoAidl) iin);
            }
            return new c com.xxx_service.IMyAidl.Stub.Proxy(obj);
        }

在而Proxy中的方法实现了AIDL接口方法的实现，_data发送数据，_reply接收数据

android.os.Parcel _data = android.os.Parcel.obtain();
 android.os.Parcel _reply = android.os.Parcel.obtain();

最后通过transat方法调用其他线程服务，调用时会挂起线程，等待服务端返回数据后继续运行
第一个参数的含义代表需要调用服务端方法的序号，简单来说就是客户端和服务端无论几个方法，他们的顺序是一样的，调用的时候不需要加上包名方法名这样去调用，只需要按照次方法序号即可，如

 static final int TRANSACTION_addXXX = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
 int FIRST_CALL_TRANSACTION  = 0x00000001;

第二个第三个参数是发送数据和接受数据，返回的数据通过reply获取到

   _result = _reply.createTypedArrayList(com.xxx.Service.CREATOR);

第三个参数flag为0代表可以双向交互，1是单向客户端向服务端发起

mRemote.transact(Stub.TRANSACTION_addXXX, _data, _reply, 0);

• 服务端
  主要是通过onTransact 这个方法去接收客户端的调用

   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_addXXX: {
                    data.enforceInterface(DESCRIPTOR);
                   com.xxx_service.XXX.Person _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.xxx_service.XXX.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addXXX(_arg0);//这个方法 会最终调用我们服务端中定义的方法
                    reply.writeNoException();
                    return true;
                }
                case TRANSACTION_addXXX2: {
                    data.enforceInterface(DESCRIPTOR);
                    com.xxx_service.XXX _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.xxx_service.XXX.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addPerson(_arg0);
                    reply.writeNoException();
                    return true;
                }
                return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

• 调用流程图
  proxy可以理解为代理人，代理帮助访问(其实就是代理模式)，sub是存根，服务端存着你要访问的东西

  
  
  image.png

其实最好自己撸一个demo 就比较好理解了。
服务端开启一个服务

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
       // throw new UnsupportedOperationException("Not yet implemented");
        return iBinder;
    }

    private IBinder iBinder = new IMyAidlInterface.Stub() {

        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }

        @Override
        public String getData() throws RemoteException {
            return "跨进城binder调用成功啦！";
        }
    };
}

然后客户端调用

public class MainActivity extends AppCompatActivity {
    private  IMyAidlInterface iMyAidlInterface;
    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.e("MainActivity", "onServiceConnected: success");
            iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("MainActivity", "onServiceDisconnected: success");
//            iLeoAidl = null;
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button bt=findViewById(R.id.bt);
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.XXX.app", "com.XXX.app.MyService"));
        bindService(intent, connection, Context.BIND_AUTO_CREATE);
        
        bt.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Log.e("MainActivity", "success"+iMyAidlInterface.getData());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }

            }
        });



    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(connection);
    }
}

需要注意的就是aidl文件 目录相同 直接拷贝就好

interface IMyAidlInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);

     String getData();
}

最后再来看一下ServiceManager在中间发挥的作用，ServiceManager（如同DNS域名服务器）服务的管理者，将Binder名字转换为Client中对该Binder的引用，使得Client可以通过Binder名字获得Server中Binder实体的引用。

image.png

下边我们看下binder的整体结构

image.png

Android系统中经常用到的BInder模式

image.png

image.png