**写作原因：跨进程通信的实现和理解是Android进阶中重要的一环。下面博主分享IPC一些相关知识、操作及自己在学习IPC过程中的一些理解。这一章是对AIDL的基本使用的介绍，由于博主也是AIDL初学者，所以一些地方阐述可能不准确，如有发现希望指正。关于使用Messenger通信参阅：Android IPC机制（二）——利用Messenger实现跨进程通信
**

AIDL基本介绍

关于AIDL，先看看Google官方文档对它的定义：AIDL是接口定义语言，它允许你定义程序接口实现跨进程的客户端与服务端的通信。在Android中，一个进程通常不能访问另一个进程的内存（这是IPC出现的原因），也就是说，进程之间要想通信，就需要将想要共享的对象分解成操作系统能够理解的原始元素通过底层来实现通信。这个过程是乏味无趣的，所以Android帮我们通过AIDL解决了这个问题。（个人翻译）此外，官方文档有说明，只有在不同的客户端与服务端通信，服务端并发处理是才有必要使用这种方式，否则选择Messenger可能更合适。相比Messenger，AIDL有这些优势：一、跨进程调用服务端的方法；二、服务端并发处理数据时。上述两种情况使用AIDL更加合适。

基本用法

下面开始掌握AIDL的使用方法，先概述一下基本用法：
1.服务端创建一个Service监听处理请求，创建一个AIDL文件将暴露给客户端的接口在AIDL文件中声明，然后在Service中实现AIDL接口。
2.客户端绑定Service获得Binder对象转化成AIDL接口所属的类型，调用接口中的方法。

具体实现

具体实现见下面（下面例子是官方举例的升级版，可以学习一下）：

本例中共有上个文件，MainActivity.java（客户端）、RemoteService.java（服务端）、Command.java（实体类）、IRemoteService.aidl（AIDL文件）、Command.aidl（AIDL文件）。

1.编写AIDL暴露接口

AIDL文件中只支持六种数据类型：基本数据类型、ArrayList、HashMap、Parcelable和AIDL。本例中我使用基本数据类型和Parcelable来阐述。

由于下面我要使用Parcelable序列化的对象Command，所以先写好Command类：

public class Command implements Parcelable{
    String name;
    int id;
    public static final Parcelable.Creator<Command> CREATOR = new Parcelable.Creator<Command>(){

        @Override
        public Command createFromParcel(Parcel source) {
            //实现从Parcel容器读取传递数据值，封装成Parcelable对象返回逻辑层
            return new Command(source);
        }

        @Override
        public Command[] newArray(int size) {
            //创建一个类型为T长度为size的数组，仅一句话即可
            return new Command[size];
        }
    };
    private Command(){

    }
    private Command(Parcel source){
        name = source.readString();
        id = source.readInt();

    }
    @Override
    public String toString() {
        return id+name;
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        //将对象映射成Parcelable对象，注意与读取的顺序相同
        dest.writeString(name);
        dest.writeInt(id);
    }
}

关于Parcelable序列化，在这里就不多加阐述了，不然这篇文章不知道要多长……序列化的基本方法见上面。官方推荐使用Parcelable是有原因的，Parcelable效率相对高，虽然实现起来比较麻烦。上面类写好之后新建一个Command.aidl文件，内容如下：

package com.example.vincebarry.googleaidl;
parcelable Command;

下面实现一下IRemoteService.aidl：

package com.example.vincebarry.googleaidl;
// Declare any non-default types here with import statements
import com.example.vincebarry.googleaidl.Command;
interface IRemoteService {
    int getPid();
    Command getCommand();
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

这里有两个部分要注意:其一是开放的方法接口要准确，其二是把序列化的Command类导入该aidl文件之中。
这样，我们就把所需的aidl文件写完了，总结一下：

1. 首先是一个业务接口aidl文件，该文件包含所有的Service暴露给客户端的方法。此外如果在该文件中使用序列化对象必须将其导入；

2. 序列化对象实现Parcelable接口，实现序列化和反序列化功能，并且将其注册到aidl文件中，注册过程见上面；

2.Service的实现

这里主要是将接口中的方法实现并且打包到（该词可能不准确）IBinder对象中将其发送到与该Service绑定的客户端去。主要实现了返回当前线程的id和将Service中的Command对象返回的逻辑，具体代码如下：

public class RemoteService extends Service {
    private Command myCommand;
    @Override
    public IBinder onBind(Intent intent) {
        myCommand = new Command();
        myCommand.setId(10);
        myCommand.setName("Hello");
        Toast.makeText(getApplicationContext(),"Remote Service bound",Toast.LENGTH_SHORT).show();
        return new IRemoteService.Stub(){

            @Override
            public int getPid() throws RemoteException {
                return Process.myPid();
            }

            @Override
            public Command getCommand() throws RemoteException {
                return myCommand;
            }


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

            }
        };
    }
}

3.客户端的实现

客户端方面主要是将Activity与Service绑定，然后将接口存根取出转化为接口，利用该接口来调用服务中的方法。具体代码如下：

ublic class MainActivity extends AppCompatActivity {
    private static final String SERVICE_ACTION = "com.example.vincebarry.googleaidl.RemoteService";
    private IRemoteService iRemoteService;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(MainActivity.this,RemoteService.class);
    }

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iRemoteService = IRemoteService.Stub.asInterface(service);
            int i = -1;
            String command = null;
            try {
                i = iRemoteService.getPid();
                command = iRemoteService.getCommand().getName()+iRemoteService.getCommand().id;
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            if(i != -1){
                Log.i("Pid","Remote Service:"+i);
                Log.i("Pid","Remote Service:"+command);
            }else{
                Log.i("Pid","Remote Service:"+"null");
            }
        }

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

总结

实现下来发现其实理解上难度并不大，只是稍显麻烦，只要前面两章理解好，对于AIDL的通信还是可以较好掌握的，关键还是要多实践。关于多线程并发的情况本文没有讲到，由于博主对于并发编程的掌握局限性的原因就暂时不实现并发情况下的AIDL通信情况，以后对并发理解加深后再作讨论。