Android深入理解IPC机制（二）浅谈Binder

Binder是Android中的一个类，它继承了IBinder接口。

1. 从IPC角度考虑，Binder是Android中的一种跨进程通信方式，Binder还可以理解为一种虚拟的物理设备，它的设备驱动是/dev/binder；
2. 从Android Framework角度考虑，Binder是连接各种Manager和相应ServiceManager的桥梁；
3. 从Android应用层来讲，Binder是客户端和服务器进行通信的媒介。当bindService的时候，服务端会返回一个Binder对象，通过这个对象，客户端可以获取服务端提供的数据或服务，包括普通服务和基于AIDL的服务；

在Android开发中，Binder主要用在Service中，包括AIDL和Messenger，实际上Messenger底层也是AIDL，所以选择用AIDL来分析Binder的工作机制。

首先我们新建一个AIDL，系统SDK会自动为我们生成一个Binder类。
（1）新建Book.java、Book.aidl、IBookManager.aidl文件

//Book.java
package com.example.qianwei.myapplication.aidl;

import android.os.Parcel;
import android.os.Parcelable;

public class Book implements Parcelable {

    private int id;
    private String name;

    public Book(int id, String name) {
        this.id = id;
        this.name = name;
    }

    protected Book(Parcel in) {
        id = in.readInt();
        name = in.readString();
    }

    public static final Creator CREATOR = new Creator() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(id);
        dest.writeString(name);
    }
}

// Book.aidl
package com.example.qianwei.myapplication.aidl;

parcelable Book;

// IBookManager.aidl
package com.example.qianwei.myapplication.aidl;

//AIDL特殊之处
import com.example.qianwei.myapplication.aidl.Book;

interface IBookManager {

    /**
     * 获取图书列表
     */
    List getBookList();

    /**
     * 添加图书
     */
    void addBook(in Book book);
}

正如我们所见，尽管Book 类与IBookManager 位于同一个包下面，但是我们仍然需要使用import将Book类导入到IBookManager ，否则编译会出错，这就是AIDL的特殊之处。

我尝试着将Book声明注释掉，果然编译器在编译阶段给出了编译失败提示：

Process 'command 'F:\sdk\build-tools\28.0.3\aidl.exe'' finished with non-zero exit value 1

（2）编译完成之后，我们可以看到build/generated/source/aidl目录下的com.example.qianwei.myapplication.aidl包里面出现了一个IBookManager.java类，这就是我们要找的类。

package com.example.qianwei.myapplication.aidl;

public interface IBookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements
            com.example.qianwei.myapplication.aidl.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.example.qianwei.myapplication.aidl.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.example.qianwei.myapplication.aidl.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.example.qianwei.myapplication.aidl.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.example.qianwei.myapplication.aidl.IBookManager))) {
                return ((com.example.qianwei.myapplication.aidl.IBookManager) iin);
            }
            return new com.example.qianwei.myapplication.aidl.IBookManager.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 {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(descriptor);
                    return true;
                }
                case TRANSACTION_getBookList: {
                    data.enforceInterface(descriptor);
                    java.util.List _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(descriptor);
                    com.example.qianwei.myapplication.aidl.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.example.qianwei.myapplication.aidl.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
                default: {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }

        private static class Proxy implements com.example.qianwei.myapplication.aidl.IBookManager {
            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 java.util.List getBookList()
                throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.example.qianwei.myapplication.aidl.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            /**
             * 添加图书
             */
            @Override
            public void addBook(com.example.qianwei.myapplication.aidl.Book book) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }

    /**
     * 获取图书列表
     */
    public java.util.List getBookList() throws
            android.os.RemoteException;

    /**
     * 添加图书
     */
    public void addBook(com.example.qianwei.myapplication.aidl.Book book)
            throws android.os.RemoteException;
}

这个类内容有点长，看起来似乎很混乱，我们先从整体上来逐步分析：

类结构图

• 两个抽象方法：getBookList()、addBook(com.example.qianwei.myapplication.aidl.Book book)，这就是我们在IBookManager.aidl类中声明的方法。同时还声明了两个整型id用于标识这两个方法，这两个id用于判断在transact过程中客户端调用的是哪个方法。
• 声明一个内部类Stub，也就是一个Binder类，当客户端与服务器位于同一进程，方法调用不会走跨进程的transact过程，否则需要执行transact过程，这个过程由Stub的内部代理类Proxy完成。

总而言之，这个接口的核心内容就是它的内部类Stub和Stub的内部代理类Proxy，我们继续分析这两个类：

DESCRIPTOR
Binder类的唯一标识，一般用当前类名表示。

private static final java.lang.String DESCRIPTOR = "com.example.qianwei.myapplication.aidl.IBookManager";

asInterface(android.os.IBinder obj)
将服务端返回的Binder类型的对象转化为客户端所需的AIDL接口类型的对象，这个过程是区分进程的，如果两端是同一进程，那么此方法返回的就是Stub对象本身，如果不是同一进程，则返回系统封装后的Stub.Proxy对象。

asBinder()
用于返回当前Binder对象。

onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)
这个方法运行在服务端中的Binder线程池中，当客户端发起跨进程请求，远程请求最终会交由此方法处理。

• 服务端通过code确定客户端请求的目标方法是什么
• 服务端从data中取出目标方法所需的参数（如果目标方法有参数）
• 目标方法执行完毕后，向reply中写入返回值（如果目标方法有返回值）

Proxy#getBookList()
此方法运行在客户端，内部实现：首先创建该方法所需要的输入型Parcel对象_data，输出型Parcel对象_reply和返回对象List；接着调用mRemote.transact发起远程过程调用（RPC）请求，同时当前线程挂起；然后服务端的onTransact方法会被调用，直到RPC过程返回后，当前线程继续执行，并从_reply中取出RPC过程的返回结果_result，最后返回_result。

Proxy#addBook(com.example.qianwei.myapplication.aidl.Book book)
此方法运行在客户端上，执行过程和getBookList()是一样的，由于此方法没有返回值，所以无需从_reply中取出取出_result。

使用Binder的时候有两点需要额外注意：
1、客户端发起远程请求时，当前进程会被挂起直至服务端进程返回数据，所以如果远程方法是耗时的，那么就不能在UI线程发起此请求；
2、由于服务端的Binder方法是运行在Binder池中的，所以Binder方法应该采取同步的方法去实现，因为它已经运行在一个线程中了。

Binder的工作机制

接下来我们思考这样一种场景，当Binder运行在服务端进程的时候进程由于某些原因异常终止，服务端的Binder会发生连接断裂（Binder死亡），导致远程调用失败，从而影响客户端功能。为了解决这个问题，Binder提供了两个非常重要的配对方法linkToDeath和unlinkToDeath，通过linkToDeath我们可以为Binder设置死亡代理，当Binder发生死亡的时候我们会收到通知，这个时候我们就可以通过一些恰当的方式重新发起连接请求从而恢复连接。我们要如何设置死亡代理呢？
1、首先，声明一个接口IBinder.DeathRecipient并实现binderDied()方法，当Binder死亡的时候系统会回调binderDied()方法，这个时候我们可以移除之前绑定的binder代理并重新绑定远程服务

private IBinder.DeathRecipient deathRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            if (bookManager == null) {
                return;
            }
            bookManager.asBinder().unlinkToDeath(deathRecipient, 0);
            bookManager = null;
            //这里重新绑定远程Service
        }
    };

2、客户端绑定远程服务成功后，给binder设置死亡代理

try {
    bookManager = IBookManager.Stub.asInterface(binder);
    binder.linkToDeath(deathRecipient, 0);
} catch (RemoteException e) {
    e.printStackTrace();
}

这样我们就成功了设置了死亡代理，另外通过Binder的方法isBinderAlive也可以判断binder是否死亡。

---

推荐阅读

Android深入理解IPC机制（一）基础知识概要
Android深入理解IPC机制（三） Android中的几种IPC方式
Android深入理解IPC机制（四）Binder连接池

参考书籍

《Android开发艺术探索》