Android Binder原理解析

前言

IPC 是 Inter-Process Communication 的缩写，含义为进程间通信。

Binder是一个很深入的话题，本篇文章不打算深入探讨Binder的底层细节，重点介绍Binder的使用以及上层原理。

Binder 是Android中的一个类，他实现了IBinder接口。Binder是Android中的一种跨进程通信方式，Binder还可以理解为一种虚拟的物理设备，他的设驱动是/dev/binder。从Framework层来说，Binder是ServiceManager连接各种Manager和相应ManagerService的桥梁。从Android应用层来说，Binder是客户端和服务端进行通信的媒介，通过binderService去绑定远程服务，进行通信。

AIDL中支持的数据类型

基本数据类型（int、long、char、boolean、double等）
String 和CharSequence
List：只支持ArrayList，里面每个元素都必须能够被AIDL支持
Map：只支持HashMap，里面的每个元素都必须被AIDL支持，包括key。
Parcelable：所有实现了Parcelable接口的对象。
mAIDL：所有的AIDL接口本身也可以在AIDL中使用。

AIDL生成结构图在这里插入图片描述

下面我们实现一个简单的AIDL并分析一下他的通信过程

Intent intent = new Intent(this, MyService.class);
bindService(intent,connection,BIND_AUTO_CREATE);

当我们调用bindService方法后。系统就会为我们把对应的远程服务端唤醒，看源码知道是通过ServiceManager 去远程服务用ClassLoader反射的方式启动需要启动的service。细节部分大家自己看frameWork层源码吧，东西太多了，这里只分析AIDL应用层流程。

Service启动之后就开始去创建BookBind类

@Override
    public IBinder onBind(Intent intent) {
        return new BookBind();
    }
    private class  BookBind extends IBookManager.Stub {

        @Override
        public List<Book> getBookList() throws RemoteException {
            return books;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            books.add(book);
            Log.d("lichao"," service addBook " + book.bookName);
        }
    }

这个类又会去

AIDLDemo\app\build\generated\source\aidl\debug\com\love\candy\aidl\IBookManager.java

public Stub() {
        //这里的this代表IBookManager，注册了IInterface接口  
        this.attachInterface(this, DESCRIPTOR);
   }
public void attachInterface(IInterface owner, String descriptor) {
        mOwner = owner;
        mDescriptor = descriptor;
    }

这里我们发现穿进来的是个IInterface，IBookManager 继承自IInterface。

这时候服务端返回了个Binder，就到客户端了

/** 
     * 连接器，通过调用Binder的方法去操作对象
     */
    ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iBookManager =  IBookManager.Stub.asInterface(service);
        }

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

我们要调用 IBookManager.Stub.asInterface(service)，这时候又会来到

//将一个IBinder对象转换成一个com.love.candy.aidl,这里就是我们平常用到的那个方法了
public static com.love.candy.aidl.IBookManager asInterface(android.os.IBinder obj) {
 if ((obj == null)) {
     return null;
 }
 //这里通过queryLocalInterface去查询有没有IInterface，
 //这个在我们调用Stub构造方法的时候就已经穿进去了。就是那个this
 android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
 //当获取到的不为空，并且是IBookManager，直接强转为IBookManager并返回
 if (((iin != null) && (iin instanceof com.love.candy.aidl.IBookManager))) {
     return ((com.love.candy.aidl.IBookManager) iin);
 }
 //否则就新创建一个Proxy
 return new com.love.candy.aidl.IBookManager.Stub.Proxy(obj);
}

当我们去调用访问远程服务的方法iBookManager.addBook(book);就会调用到Proxy中的addBook方法。

@Override
    public void addBook(com.love.candy.aidl.Book book) throws android.os.RemoteException {
        //去获取序列化对象
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
            //把本aidl通过ndk写入到一个地方
            _data.writeInterfaceToken(DESCRIPTOR);
            //如果传入的值不是空
            if ((book != null)) {
                //把传入的值序列化
                _data.writeInt(1);
                book.writeToParcel(_data, 0);
            } else {
                _data.writeInt(0);
            }
            //调用了Binder的transact方法
            mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
            _reply.readException();
        } finally {
            _reply.recycle();
            _data.recycle();
        }
    }

把对象进行一些封装，他最终会调用mRemote.transact方法。

public final boolean transact(int code, Parcel data, Parcel reply,
        int flags) throws RemoteException {
    if (false) Log.v("Binder", "Transact: " + code + " to " + this);

    if (data != null) {
        data.setDataPosition(0);
    }
    //这里会通过Binder的onTransact方法回调到我们Stub中
    boolean r = onTransact(code, data, reply, flags);
    if (reply != null) {
        reply.setDataPosition(0);
    }
    return r;
}

这里会又回调到我们Stub中的onTransact。

@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply,
                                                                             int flags) {
    switch (code) {
        case TRANSACTION_addBook: {
            data.enforceInterface(DESCRIPTOR);
            com.love.candy.aidl.Book _arg0;
            //这里的值和Proxy中的值对应
            if ((0 != data.readInt())) {
                //通过data创建了个Book对象
                _arg0 = com.love.candy.aidl.Book.CREATOR.createFromParcel(data);
            } else {
                _arg0 = null;
            }
            //回调抽象方法
            this.addBook(_arg0);
            reply.writeNoException();
            return true;
        }
    }
    return super.onTransact(code, data, reply, flags);
}

这里把我们传过来的对象进行解析，并回调了Stub的抽象方法addBook，这个抽象方法就是我们再Service中重写的那个方法

private class  BookBind extends IBookManager.Stub {
        @Override
        public List<Book> getBookList() throws RemoteException {
            return books;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            books.add(book);
            Log.d("lichao"," service addBook " + book.bookName);
        }
    }

最终调用了服务端中的addBook方法，把客户端加入的book加入到了服务端列表中。获取远程服务数据和加入数据流程差不多，只不过获取数据会有返回值。

流程图如下所示

引用了百度大神的图。

小结

当我们的客户端调用远程服务方法，被调用的方法运行在服务端的Binder线程池中，同时客户端线程会被挂起，这个时候如果服务端方法执行比较耗时时，就会导致客户端线程长时间阻塞在哪里，而如果这个客户端是UI线程的话，就会造成ANR，因此我们要避免在客户端的UI线程中去访问远程方法。由于客户端的onServiceConnected和onServiceDisconnected方法都运行在UI线程中，因此这里面也不要做耗时操作。另外，由于服务端的方法本身就运行在服务端的binder线程池中，所以服务端方法本身就可以执行大量的耗时操作，这个时候切记不要在服务端方法中创建新的线程去执行异步任务了。

Github demo 地址

binderService启动流程分析

最后

Android学习是一条漫长的道路，我们要学习的东西不仅仅只有表面的技术，还要深入底层，弄明白下面的原理，只有这样，我们才能够提高自己的竞争力，在当今这个竞争激烈的世界里立足。

常言：种一棵树最好的时间有两个，一个是十年前，另一个就是现在。