在前面《Activity与Service数据交互的几种方式》文章中，讲解了AIDL是什么，AIDL的使用流程，AIDL支持的数据类型，使用过程中需要注意的事项，以及具体的实例。不了解的朋友可以先去浏览一下。

AIDL实际上底层是Binder机制，如果不了解Binder机制的可以查看我前面的文章《进程间通信之Binder机制浅析》。AIDL其本质是为了让我们更方便的进行进程间通信，在知道它底层是Binder机制，那它到底为我们做了什么呢？接下来我们根据分析前文中AIDL使用实例进行分析。

AIDL编译后生成Java文件

在前面文章中，我们知道使用AIDL需要定义相应的AIDL文件，编译后会自动为我们生成相应的Java文件：

• 定义AIDL文件

interface IFriendService {

    void addFriend(in Friend friend);

    void registerListener(in IOnNewFriendAddedListener listener);

    void unRegisterListener(in IOnNewFriendAddedListener listener);
}

• 编译后生成的Java文件

IFriendService

我们可以看到生成的IFriendService接口继承自IInterface，在《进程间通信之Binder机制浅析》一文中我们有讲解到，IInterface是进程间通信的基础接口，创建一个新的通信接口，都需要从继承它开始。

文件中还生成了我们定义的方法，还有一个抽象的Stub内部类。

Stub

public static abstract class Stub extends android.os.Binder implements com.demo.service.aidl.IFriendService {
    // 描述符，用于查找接口
    private static final java.lang.String DESCRIPTOR = "com.demo.service.aidl.IFriendService";
    public Stub() {
        // Binder中的方法，将具体的接口、描述符和Binder进行绑定
        this.attachInterface(this, DESCRIPTOR);
    }
    // 将IBinder转换为具体的接口，判断如果不在一个进程（即跨进程），则生成代理返回
    public static com.demo.service.aidl.IFriendService asInterface(android.os.IBinder obj) {
        if ((obj==null)) {
            return null;
        }
        // 通过描述符查询本地接口
        android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (((iin!=null)&&(iin instanceof com.demo.service.aidl.IFriendService))) { // 判断本地是否存在
            return ((com.demo.service.aidl.IFriendService)iin);
        }
        // 本地不存在，则生成代理
        return new com.demo.service.aidl.IFriendService.Stub.Proxy(obj);
    }
    // IInterface接口方法具体实现
    @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 {
        switch (code) {
            case INTERFACE_TRANSACTION: // 获取接口描述符
            {
                reply.writeString(DESCRIPTOR);
                return true;
            }
            case TRANSACTION_addFriend: // 执行定义的接口方法
            {
                data.enforceInterface(DESCRIPTOR);
                com.demo.service.aidl.bean.Friend _arg0;
                if ((0!=data.readInt())) {
                    _arg0 = com.demo.service.aidl.bean.Friend.CREATOR.createFromParcel(data);
                }
                else {
                    _arg0 = null;
                }
                this.addFriend(_arg0);
                reply.writeNoException();
                return true;
            }
            ...
        }
        return super.onTransact(code, data, reply, flags);
    }
    // 跨进程通信，生成的代理类，返回给客户端
    private static class Proxy implements com.demo.service.aidl.IFriendService {
        ...
    }

    // 操作标识符，在onTransact方法中根据这些code来进行相应的操作
    static final int TRANSACTION_addFriend = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    static final int TRANSACTION_unRegisterListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
}

• Stub继承Binder，拥有远程通信能力。
• Stub是一个抽象类，实现了IInterface接口方法，并没有实现IFriendService接口的具体方法，具体的方法将由Server端实现，这样Client端就可操作Server端实现的方法。
• Stub的asInterface()方法中，进行了查询本地接口，如果本地没有，则会生成代理对象。也就是说Client端调用IFriendService.Stub.asInterface()获取接口对象时，如果是跨进程的，则拿到的会是Server端本地对象的一个代理对象；如果是同进程操作，拿到的是Server端本地对象。

Proxy

private static class Proxy implements com.demo.service.aidl.IFriendService {
    private android.os.IBinder mRemote; //代理的远端Binder
    Proxy(android.os.IBinder remote) {
        mRemote = remote;
    }

    @Override
    public android.os.IBinder asBinder() {
        return mRemote;
    }
    public java.lang.String getInterfaceDescriptor() {
        return DESCRIPTOR;
    }

    @Override
    public void addFriend(com.demo.service.aidl.bean.Friend friend) 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 ((friend!=null)) {
                _data.writeInt(1);
                friend.writeToParcel(_data, 0);
            }
            else {
                _data.writeInt(0);
            }
            // 最终交由远端Binder进行相应操作
            mRemote.transact(Stub.TRANSACTION_addFriend, _data, _reply, 0);
            _reply.readException();
        }
        finally {
            _reply.recycle();
            _data.recycle();
        }
    }
    ...
}

Proxy很简单，是Stub的内部类，实现了IFriendService接口方法、IInterface接口方法，在实现的IFriendService的接口方法中，最终还是交给代理的远端对象进行操作。

总结

下面我们来总结下AIDL具体做了什么：

1. 根据AIDL文件，生成Java接口，该接口继承IInterface
2. 生成Stub抽象内部类，该类继承Binder，实现了IInterface接口方法，抽象我们定义的方法留给Server端实现。
3. 在Stub类中提供asInterface()方法，提供将IBinder转换成我们定义的接口的能力；在其中通过Binder的方法查询本地接口进行判断，没有则代表是跨进程的，则生成代理对象。
4. 生成Proxy类，该类为Stub内部类，其实现了我们定义的接口，在接口方法中交由映射的实际接口的transact()方法处理，最终实际上是Stub类的onTransact()方法进行处理。

AIDL实际上就是通过扩展Binder，来让我们实现跨进程通信。只不过它为我们做好了相应的封装处理，我们只需要关心具体的业务逻辑。

如果我们要自己扩展Binder实现跨进程通信，那么我们只需要模仿上面Stub和Proxy编写相应类就可以了。

最后附上一张图来进行理解：

AIDL

Thanks

• Gityuan Binder系列
• Android 进阶9：进程通信之 AIDL 解析