Android系统中，涉及到多进程间的通信底层都是依赖于Binder IPC机制。例如当进 程A中的Activity要向进程B中的Service通信，这便需要依赖于Binder IPC。不仅于 此，整个Android系统架构中，大量采用了Binder机制作为IPC（进程间通信， Interprocess Communication）方案。
当然也存在部分其他的IPC方式，如管道、SystemV、Socket等。那么Android为什 么不使用这些原有的技术，而是要使开发一种新的叫Binder的进程间通信机制呢？
（顺手留下GitHub链接，需要获取相关面试等内容的可以自己去找）
https://github.com/xiangjiana/Android-MS
(VX：mm14525201314)
为什么要使用Binder？
性能方面 在移动设备上（性能受限制的设备，比如要省电），广泛地使用跨进程通信对通信 机制的性能有严格的要求，Binder相对于传统的Socket方式，更加高效。Binder数 据拷贝只需要一次，而管道、消息队列、Socket都需要2次，共享内存方式一次内 存拷贝都不需要，但实现方式又比较复杂。
安全方面
传统的进程通信方式对于通信双方的身份并没有做出严格的验证，比如Socket通信 的IP地址是客户端手动填入，很容易进行伪造。然而，Binder机制从协议本身就支 持对通信双方做身份校检，从而大大提升了安全性。
IPC原理
从进程角度来看IPC（Interprocess Communication）机制
每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。例如，对应一 个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间。当然内核空间的 大小是可以通过参数配置调整的。对于用户空间，不同进程之间是不能共享的，而 内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享 的内核内存空间来完成底层通信工作的。Client端与Server端进程往往采用ioctl等方 法与内核空间的驱动进行交互。
Binder原理
Binder通信采用C/S架构，从组件视角来说，包含Client、Server、ServiceManager 以及Binder驱动，其中ServiceManager用于管理系统中的各种服务。架构图如下所 示：
Binder通信的四个角色
Client进程： 使用服务的进程。
Server进程： 提供服务的进程。
ServiceManager进程： ServiceManager的作用是将字符形式的Binder名字转化成 Client中对该Binder的引用，使得Client能够通过Binder名字获得对Server中Binder 实体的引用。
Binder驱动： 驱动负责进程之间Binder通信的建立，Binder在进程之间的传递， Binder引用计数管理，数据包在进程之间的传递和交互等一系列底层支持。
Binder运行机制
图中Client/Server/ServiceManage之间的相互通信都是基于Binder机制。既然基于 Binder机制通信，那么同样也是C/S架构，则图中的3大步骤都有相应的Client端与 Server端。
注册服务(addService)： Server进程要先注册Service到ServiceManager。该过 程：Server是客户端，ServiceManager是服务端。
获取服务(getService)： Client进程使用某个Service前，须先向ServiceManager中 获取相应的Service。该过程：Client是客户端，ServiceManager是服务端。
使用服务： Client根据得到的Service信息建立与Service所在的Server进程通信的通 路，然后就可以直接与Service交互。该过程：Client是客户端，Server是服务端。
图中的Client，Server，Service Manager之间交互都是虚线表示，是由于它们彼此 之间不是直接交互的，而是都通过与Binder驱动进行交互的，从而实现IPC通信 （Interprocess Communication）方式。其中Binder驱动位于内核空间，Client， Server，Service Manager位于用户空间。Binder驱动和Service Manager可以看做 是Android平台的基础架构，而Client和Server是Android的应用层，开发人员只需自 定义实现Client、Server端，借助Android的基本平台架构便可以直接进行IPC通 信。
Binder运行的实例解释
首先我们看看我们的程序跨进程调用系统服务的简单示例，实现浮动窗口部分代 码：
//获取WindowManager服务引用
WindowManager wm = (WindowManager) getSystemService(getApplicati on().WINDOW_SERVICE);
//布局参数layoutParams相关设置略...
View view = LayoutInflater.from(getApplication()).inflate(R.layo ut.float_layout, null);
//添加view
wm.addView(view, layoutParams);注册服务(addService)： 在Android开机启动过程中，Android会初始化系统的各种 Service，并将这些Service向ServiceManager注册（即让ServiceManager管理）。 这一步是系统自动完成的。
获取服务(getService)： 客户端想要得到具体的Service直接向ServiceManager要 即可。客户端首先向ServiceManager查询得到具体的Service引用，通常是Service 引用的代理对象，对数据进行一些处理操作。即第2行代码中，得到的wm是 WindowManager对象的引用。
使用服务： 通过这个引用向具体的服务端发送请求，服务端执行完成后就返回。即 第6行调用WindowManager的addView函数，将触发远程调用，调用的是运行在 systemServer进程中的WindowManager的addView函数。
使用服务的具体执行过程
- Client通过获得一个Server的代理接口，对Server进行调用。
- 代理接口中定义的方法与Server中定义的方法是一一对应的。
- Client调用某个代理接口中的方法时，代理接口的方法会将Client传递的参数打 包成Parcel对象。
- 代理接口将Parcel发送给内核中的Binder Driver。
- Server会读取Binder Driver中的请求数据，如果是发送给自己的，解包Parcel 对象，处理并将结果返回。
- 整个的调用过程是一个同步过程，在Server处理的时候，Client会Block住。因 此Client调用过程不应在主线程。
AIDL (Android Interface Definition Language) 是一种接口定义语言，用于生成可以 在Android设备上两个进程之间进行进程间通信(Interprocess Communication, IPC) 的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service） 对象的操作，就可以使用AIDL生成可序列化的参数，来完成进程间通信。
简言之，AIDL能够实现进程间通信，其内部是通过Binder机制来实现的，后面会 具体介绍，现在先介绍AIDL的使用。
AIDL的实现一共分为三部分，一部分是客户端，调用远程服务。一部分是服务端， 提供服务。最后一部分，也是最关键的是AIDL接口，用来传递的参数，提供进程间 通信。
先在服务端创建AIDL部分代码。
AIDL文件 通过如下方式新建一个AIDL文件
默认生成格式
interface IBookManager {
/**
* Demonstrates some basic types that you can use as paramet ers
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, flo at aFloat, double aDouble, String aString);
}默认如下格式，由于本例要操作Book类，实现两个方法，添加书本和返回书本列 表。
定义一个Book类，实现Parcelable接口。
public class Book implements Parcelable {
public int bookId;
public String bookName;
public Book() {
}
public Book(int bookId, String bookName) {
this.bookId = bookId;
this.bookName = bookName;
}
public int getBookId() {
return bookId;
}
public void setBookId(int bookId) {
this.bookId = bookId;
}
public String getBookName() {
return bookName;
}
public void setBookName(String bookName) {
this.bookName = bookName;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(this.bookId);
dest.writeString(this.bookName);
}
protected Book(Parcel in) {
this.bookId = in.readInt();
this.bookName = in.readString();
}
public static final Parcelable.Creator<Book> CREATOR = new P arcelable.Creator<Book>() {
@Override
public Book createFromParcel(Parcel source) {
return new Book(source);
}
@Override
public Book[] newArray(int size) {
return new Book[size];
}
};
}由于AIDL只支持数据类型:基本类型（int，long，char，boolean等），String， CharSequence，List，Map，其他类型必须使用import导入，即使它们可能在同一 个包里，比如上面的Book。 最终IBookManager.aidl 的实现
// Declare any non-default types here with import statements import com.lvr.aidldemo.Book;
interface IBookManager {
/**
* Demonstrates some basic types that you can use as paramet ers
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, flo at aFloat, double aDouble, String aString);
void addBook(in Book book); List<Book> getBookList();
}注意： 如果自定义的Parcelable对象，必须创建一个和它同名的AIDL文件，并在其 中声明它为parcelable类型。
Book.aidl
// Book.aidl
package com.lvr.aidldemo;
parcelable Book;以上就是AIDL部分的实现，一共三个文件。 然后Make Project ，SDK为自动为我们生成对应的Binder类。 在如下路径下：
其中该接口中有个重要的内部类Stub ，继承了Binder 类，同时实现了 IBookManager接口。 这个内部类是接下来的关键内容。
public static abstract class Stub extends android.os.Binder impl ements com.lvr.aidldemo.IBookManager{}服务端 服务端首先要创建一个Service用来监听客户端的连接请求。然后在Service 中实现Stub 类，并定义接口中方法的具体实现。
//实现了AIDL的抽象函数
private IBookManager.Stub mbinder = new IBookManager.Stub() {
@Override
public void basicTypes(int anInt, long aLong, boolean aBoole an, float aFloat, double aDouble, String aString) throws RemoteE xception {
//什么也不做
}
@Override
public void addBook(Book book) throws RemoteException {
//添加书本
if (!mBookList.contains(book)) {
mBookList.add(book); }
}
@Override
public List<Book> getBookList() throws RemoteException {
return mBookList;
}
};当客户端连接服务端，服务端就会调用如下方法：
public IBinder onBind(Intent intent) {
return mbinder;
}就会把Stub实现对象返回给客户端，该对象是个Binder对象，可以实现进程间通 信。 本例就不真实模拟两个应用之间的通信，而是让Service另外开启一个进程来 模拟进程间通信。
<service
android:name=".MyService"
android:process=":remote">
<intent-filter>
<category android:name="android.intent.category.DEFAULT" />
<action android:name="com.lvr.aidldemo.MyService" />
</intent-filter>
</service>android:process=":remote"设置为另一个进程。 <action android:name="com.lvr.aidldemo.MyService"/> 是为了能让其他apk隐式 bindService。通过隐式调用的方式来连接service，需要把category设为default， 这是因为，隐式调用的时候，intent中的category默认会被设置为default。
客户端
首先将服务端工程中的aidl文件夹下的内容整个拷贝到客户端工程的对应位置下， 由于本例的使用在一个应用中，就不需要拷贝了，其他情况一定不要忘记这一步。
客户端需要做的事情比较简单，首先需要绑定服务端的Service。
Intent intentService = new Intent();
intentService.setAction("com.lvr.aidldemo.MyService");
intentService.setPackage(getPackageName());
intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
MyClient.this.bindService(intentService, mServiceConnection, BIN
D_AUTO_CREATE);
Toast.makeText(getApplicationContext(), "绑定了服务", Toast.LENGTH _SHORT).show();将服务端返回的Binder对象转换成AIDL接口所属的类型，接着就可以调用AIDL中的 方法了。
if (mIBookManager != null) {
try {
mIBookManager.addBook(new Book(18, "新添加的书"));
Toast.makeText(getApplicationContext(), mIBookManager.ge
tBookList().size() + "", Toast.LENGTH_SHORT).show();
} catch (RemoteException e) {
e.printStackTrace();
}
}Binder机制的运行主要包括三个部分：注册服务、获取服务和使用服务。 其中注册 服务和获取服务的流程涉及C的内容，由于个人能力有限，就不予介绍了。
本篇文章主要介绍使用服务时，AIDL的工作原理。
①.Binder对象的获取
Binder是实现跨进程通信的基础，那么Binder对象在服务端和客户端是共享的，是 同一个Binder对象。在客户端通过Binder对象获取实现了IInterface接口的对象来调 用远程服务，然后通过Binder来实现参数传递。
那么如何维护实现了IInterface接口的对象和获取Binder对象呢？
服务端获取Binder对象并保存IInterface接口对象 Binder中两个关键方法：
public class Binder implement IBinder {
void attachInterface(IInterface plus, String descriptor)
IInterface queryLocalInterface(Stringdescriptor) //从IBinder 中继承而来
......
}Binder具有被跨进程传输的能力是因为它实现了IBinder接口。系统会为每个实现了 该接口的对象提供跨进程传输，这是系统给我们的一个很大的福利。
Binder具有的完成特定任务的能力是通过它的IInterface的对象获得的，我们可以 简单理解attachInterface方法会将（descriptor，plus）作为（key,value）对存入 Binder对象中的一个Map对象中，Binder对象可通过attachInterface方法持有一个 IInterface对象（即plus）的引用，并依靠它获得完成特定任务的能力。 queryLocalInterface方法可以认为是根据key值（即参数 descriptor）查找相应的 IInterface对象。 在服务端进程，通过实现 private IBookManager.Stub mbinder = new IBookManager.Stub() {}抽象类，获得Binder对象。 并保存了IInterface对象。
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}客户端获取Binder对象并获取IInterface接口对象 通过bindService获得Binder对象
MyClient.this.bindService(intentService, mServiceConnection, BIN D_AUTO_CREATE);然后通过Binder对象获得IInterface对象。
private ServiceConnection mServiceConnection = new ServiceConnec tion() {
@Override
public void onServiceConnected(ComponentName name, IBinder b inder) {
//通过服务端onBind方法返回的binder对象得到IBookManager的实例， 得到实例就可以调用它的方法了
mIBookManager = IBookManager.Stub.asInterface(binder);
}
@Override
public void onServiceDisconnected(ComponentName name) {
mIBookManager = null;
}
};其中 asInterface(binder)方法如下：
public static com.lvr.aidldemo.IBookManager asInterface(android. os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPT OR);
if (((iin != null) && (iin instanceof com.lvr.aidldemo.IBook Manager))) {
return ((com.lvr.aidldemo.IBookManager) iin);
}
return new com.lvr.aidldemo.IBookManager.Stub.Proxy(obj);
}先通过 queryLocalInterface(DESCRIPTOR);查找到对应的IInterface对象，然后 判断对象的类型，如果是同一个进程调用则返回IBookManager对象，由于是跨进 程调用则返回Proxy对象，即Binder类的代理对象。
②.调用服务端方法
获得了Binder类的代理对象，并且通过代理对象获得了IInterface对象，那么就可以 调用接口的具体实现方法了，来实现调用服务端方法的目的。 以addBook方法为例，调用该方法后，客户端线程挂起，等待唤醒：
@Override public void addBook(com.lvr.aidldemo.Book book) th rows android.os.RemoteException
{
..........
//第一个参数：识别调用哪一个方法的ID
//第二个参数：Book的序列化传入数据
//第三个参数：调用方法后返回的数据 //最后一个不用管
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply , 0);
_reply.readException();
}
..........
}省略部分主要完成对添加的Book对象进行序列化工作，然后调用 transact 方 法。
Proxy对象中的transact调用发生后，会引起系统的注意，系统意识到Proxy对象想 找它的真身Binder对象（系统其实一直存着Binder和Proxy的对应关系）。于是系统 将这个请求中的数据转发给Binder对象，Binder对象将会在onTransact中收到Proxy 对象传来的数据，于是它从data中取出客户端进程传来的数据，又根据第一个参数 确定想让它执行添加书本操作，于是它就执行了响应操作，并把结果写回reply。代 码概略如下：
case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);
com.lvr.aidldemo.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.lvr.aidldemo.Book.CREATOR.createFromParcel(d ata);
} else {
_arg0 = null;
}
//这里调用服务端实现的addBook方法
this.addBook(_arg0);
reply.writeNoException();
return true;
}然后在 transact 方法获得 _reply 并返回结果，本例中的addList方法没有返回 值。
客户端线程被唤醒。因此调用服务端方法时，应开启子线程，防止UI线程堵塞，导 致ANR。
（顺手留下GitHub链接，需要获取相关面试等内容的可以自己去找）
https://github.com/xiangjiana/Android-MS
(VX：mm14525201314)
原文：https://blog.51cto.com/14541311/2469344