AIDL的使用--实现跨进程通信

AIDL（Android Interface Definition Language）是Android接口定义语言，简单讲在Android开发过程中当遇到多进程开发或者进程间通信的问题时，可以借助该工具简单快速的实现。下面介绍使用AIDL进行进行跨进程通信的实现步骤。
1.创建一个空项目AIDLDemo,一开始项目中只有MainActivity一个Java文件。
2.在与java平级的目录下创建一个文件夹，取名为aidl，如下图所示。

3.在aidl文件夹下创建一个AIDL文件，可以右键aidl文件夹，在new中找到AIDL，点击创建aidl文件，取名为IRemoteService，这时在aidl文件夹下回生成与java文件具有同样目录结构，其中包含了一个interface IRemoteService。

// IRemoteService.aidl
package com.example.administrator.aidldemo;

// Declare any non-default types here with import statements

interface IRemoteService {

    int getPid();//自己定义的方法
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

4.如果aidl文件的创建过程不出错误，会在AIDLDemo\app\build\generated\source\aidl\debug\com\example\administrator\aidldemo\IRemoteService.java找到生成的Java类，该类包含了一个抽象类型的静态类Stub，代表的是一个Binder对象。如果没有生成可以点击Build的ReBuild Project刷新一下项目。

5.这个时候AIDL的基本条件已经准备好，需要我们创建客户端与服务端，其中客户端其实就是Activity，而服务端我们需要创建一个Service来实现，先创建一个RemoteService类如下，我们在其中定义了一个IRemoteService.Stub对象，将我们在aidl接口中定义好的方法进行具体的实现。并通过Service的onBind方法将该Binder对象返回给客户端Activity。注意的是需要在清单文件中将Service的process进行设置为android:process=”:remote”，其中的”:remote”可以自己设定。

package com.example.administrator.aidldemo;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.Process;
import android.os.RemoteException;

public class RemoteService extends Service {
    public RemoteService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }

    private final IRemoteService.Stub binder = new IRemoteService.Stub() {

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


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

6.客户端MainActivity需要做的工作就是bindService和创建一个ServiceConnection对象两个步骤就行了。

package com.example.administrator.aidldemo;

import android.app.Service;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.Process;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent();
        intent.setClass(this,RemoteService.class);
        bindService(intent,connection, Service.BIND_AUTO_CREATE);
    }
    private IRemoteService remoteService;
    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            remoteService = IRemoteService.Stub.asInterface(iBinder);
            try {
                Log.d("Client Id:", Process.myPid()+"");
                Log.d("Remote Id:",remoteService.getPid()+"");
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            remoteService = null;
        }
    };
}

7.到这里利用AIDL就可以实现MainActivity与RemoteService两个处于不同进程的组件的通信啦。效果如下，可以看出进程不同的pid。

另外，有时我们也需要在进程间传输我们自己定义的Parcelable对象，具体方法如下。
1.在Java路径下创建一个实现了Parcelable的类MyProcess。其中的大部分代码都是自己生成的，只需要按照如下方法加入自己的数据类型。

package com.example.administrator.aidldemo;

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

/**
 * Created by Administrator on 2018/3/18.
 */

public class MyProcess implements Parcelable {
    public int pid;
    public String name;

    public MyProcess(int id,String na) {
        pid = id;
        name = na;
    }

    protected MyProcess(Parcel in) {
        pid = in.readInt();
        name = in.readString();
    }

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

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

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

    @Override
    public void writeToParcel(Parcel parcel, int i) {
        parcel.writeInt(pid);
        parcel.writeString(name);
    }
}

2.在aidl路径下添加一个file文件，取名为MyProcess.aidl。

package com.example.administrator.aidldemo;
parcelable MyProcess;

3.在aidl路径下创建aidl文件IMyProcess，并使用自己的数据类型MyProcess，注意需要import该类，这是使用AIDL的基本要求。

// IMyProcess.aidl
package com.example.administrator.aidldemo;

// Declare any non-default types here with import statements
import com.example.administrator.aidldemo.MyProcess;
interface IMyProcess {
    MyProcess getMyProcess(in int p);
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

4.到这里其实已经把自定义对象的部分完成了，剩下的过程可以参考上面的内容，如在服务端RemoteService中定义一个binder2，并通过我们在IMyProcess接口中定义的getMyProcess方法获得一个MyProcess对象。

private final IMyProcess.Stub binder2 = new IMyProcess.Stub() {


        @Override
        public MyProcess getMyProcess(int p) throws RemoteException {
            return new MyProcess(p,"jacket_Xu");
        }

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

        }
    };

关于AIDL的使用基本就是这样，当然还有其他内容如aidl的数据流向标准in，out,inout的使用以后会再讲解。
结束！