跨进程通信之：AIDL

Android应用是独立的进程、独立的内存，所以在不同进程间传递数据会稍微麻烦些，基于这种情况Android SDK提供了4种通信方式，分别为：AIDL、Content Provider、Broadcast、Activity。今天介绍AIDL通信方式的实现。

AIDL

aidl是一种Service通信，通过定义aidl接口实现数据的传输，首先定义服务端和客户端，服务端即Service，客户端即服务端Service的绑定实现。

支持的数据类型：基本数据类型、自定义类型(Parcelable接口的实现)

基本数据类型的实现

在main文件夹下创建aidl文件夹，再新建aidl接口文件

代码结构

aidl接口里定义调用方法，如下：

interface IMyAidlInterface {

    int getInt();
    float getFloadt();
    double getDouble();
    long getLong();
    boolean getBoolean();
    String getString();

    void setData(int aInt,float aFloat,double aDouble,long aLong,boolean aBoolean,String aString);
}

定义完后需要Make Project一下工程，接着在服务端Service里实现该aidl接口的Stub内部类，并在onBind()里返回，Stub就是一个Binder的子类，所以AIDL归根结底就是Binder通信。

/**
 * Created by 你的样子 on 2018/8/3.
 * 服务端
 */
public class AService extends Service {

    private int a;
    private float b;
    private double c;
    private long d;
    private boolean e;
    private String f;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new MyBinder();
    }

    private class MyBinder extends IMyAidlInterface.Stub {

        @Override
        public int getInt() throws RemoteException {
            return a;
        }

        @Override
        public float getFloat() throws RemoteException {
            return b;
        }

        @Override
        public double getDouble() throws RemoteException {
            return c;
        }

        @Override
        public long getLong() throws RemoteException {
            return d;
        }

        @Override
        public boolean getBoolean() throws RemoteException {
            return e;
        }

        @Override
        public String getString() throws RemoteException {
            return f;
        }

        @Override
        public void setData(int aInt, float aFloat, double aDouble, long aLong, boolean aBoolean, String aString) throws RemoteException {
            a = aInt;
            b = aFloat;
            c = aDouble;
            d = aLong;
            e = aBoolean;
            f = aString;
        }
    }
}

到此基本数据类型服务端实现编写完毕。

接下来是客户端实现，把aidl文件拷贝到另一个工程中，再次Make project一下，需注意的是aidl文件的包名必须一致，然后在Activity中绑定服务端Service即可。

public class MainActivity extends AppCompatActivity {

    private IMyAidlInterface iMyAidlInterface;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bindService(new Intent("ni.de.yang.zi"),new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        },BIND_AUTO_CREATE);
        findViewById(R.id.add).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    iMyAidlInterface.setData(8, 0.9f, 9, 1000000, true, "示例");
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
        findViewById(R.id.get).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Log.i("==TAG==","获取字符串 ：" + iMyAidlInterface.getString());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

end.

自定义类型的实现

首先在Java目录下创建自定义类型实体类，并实现Parcelable接口。

public class User implements Parcelable {

    private String name;

    public User(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    protected User(Parcel in) {
        name = in.readString();
    }

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

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

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

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

    public void readFromParcel(Parcel dest) {
        //注意，此处的读值顺序应当是和writeToParcel()方法中一致的
        name = dest.readString();
    }
}

接下来在aidl目录下新建跟User.java类同包同名aidl文件，再导入User完整包名，声明自定义类型parcelable，

注意：

1.User.java跟User.aidl必须是相同包名，名字也一样，不然编译不通过。
2.parcelable为小写

// User.aidl
package com.yscall.testt.bean;
parcelable User;

到此新类型已定义完了，接下来是服务端的实现，具体流程跟基本类型的实现一样，先建立一个逻辑操作aidl文件，并导入自定义类型完整包名，再Make project一下。

package com.yscall.testt;

//完整包名
import com.yscall.testt.bean.User;

interface CustomAidlInterface {

    User getUser();

    void addUser(inout User user);

}

创建服务端Service

public class BService extends Service {

    private User user;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new MyBinder();
    }

    class MyBinder extends CustomAidlInterface.Stub{

        @Override
        public User getUser() throws RemoteException {
            return user;
        }

        @Override
        public void addUser(User user) throws RemoteException {
            BService.this.user = user;
        }
    }}

项目结构如下：

项目结构

接着是客户端的实现，把CustomAidlIterface.aidl、User.aidl拷贝到另一个工程中，包名需一致，再Make project一下。最后在Activity里绑定调用即可。

public class ClientActivity extends Activity {

    private CustomAidlInterface customAidlInterface;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bindService(new Intent("ni.de.yang.zi"), new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                customAidlInterface = CustomAidlInterface.Stub.asInterface(service);
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        }, BIND_AUTO_CREATE);
        findViewById(R.id.add).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    customAidlInterface.addUser(new User("迷糊"));
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
        findViewById(R.id.get).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    User user = customAidlInterface.getUser();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

到此自定义类型的使用就基本实现了。

结语：AIDL传输数据的前提是两个进程必须是运行状态。否无法传输。