Android Aidl的使用第一章客户端服务端通信

前言

Aidl 用于跨进程通信。

用 Aidl 实现跨进程通信的步骤，大致为：

• 1.确认要传入的数据，序列化数据类；
• 2.创建 Aidl 接口；
• 3.服务端 Service 实现 Aidl 的接口；
• 4.客户端绑定服务端，与服务端通信。

本例包名：com.test.relearnaidl

1.确认要传入的数据，序列化实体数据类

Aidl 支持的数据类型有：

实际开发中，我们要传入的数据可能是 JavaBean 类型的，需要先进行序列化，Android 的序列化推荐用 Parcelable 。
序列化后，本例的 Car 类就可以通过 Aidl 传输了。

package com.test.relearnaidl.aidl;

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

import androidx.annotation.NonNull;

public class Car implements Parcelable {

    private int id;
    private String name;

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

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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

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

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

    @NonNull
    @Override
    public String toString() {
        return String.format("[id:%d, name:%s]",id, name);
    }
}

AS 的代码补确实 6 ，我们写好参数后，直接代码补全生成序列化的一系列方法了。

2.创建 Aidl 接口

2.1 新建 aidl 文件夹

在 project 视图下，在 main 目录新建 Aidl File ，会生成一个 Aidl 文件夹，用来存放 aidl 文件。

2.2 编写 aidl 接口

新建 ICarManager.aidl 文件， 本例中，只添加获取和增加的接口，

// ICarManager.aidl
package com.test.relearnaidl.aidl;

import com.test.relearnaidl.aidl.Car;
// Declare any non-default types here with import statements

interface ICarManager {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    List<Car> getCarList();
    void addNewCar(in Car car);
}

因为我们用的是自定义的 Parcelable 对象 Car，所以还需要编写一个 Car.aidl ，并声明为 Parcelable 类型。

package com.test.relearnaidl.aidl;
parcelable Car;

需要注意的是，数据类 和 aidl文件 的包的路径（或者说目录结构）要对应上。
本例包名：com.test.relearnaidl ，
我在 java 目录下新建了一个文件夹aidl来存放 Car 类，
所以 aidl 目录下也需要新建 aidl 文件夹来存放这两个 aidl 文件；
否则会报错 couldn't find import for class 。

3.服务端实现

3.1 实现 aidl 接口

其实就是 onBind 中返回一个 Binder 对象，这个 Binder 对象继承 ICarManager.Stub() 并实现了它内部的方法。

package com.test.relearnaidl.service;

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

import androidx.annotation.Nullable;

import com.test.relearnaidl.aidl.Car;
import com.test.relearnaidl.aidl.ICarManager;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class CarManagerService extends Service {

    private CopyOnWriteArrayList<Car> mCarList = new CopyOnWriteArrayList<Car>();

    private Binder mBinder = new ICarManager.Stub() {
        @Override
        public List<Car> getCarList() throws RemoteException {
            return mCarList;
        }

        @Override
        public void addNewCar(Car car) throws RemoteException {
            mCarList.add(car);
        }
    };

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

    @Override
    public void onCreate() {
        super.onCreate();
        mCarList.add(new Car(100, "SUV 100"));
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
}

3.2 服务端配置

既然要跨进程通信，方然要让 Service 运行在独立进程中，配置下，

<service android:name=".service.CarManagerService"
        android:process=":remote">
</service>

还有一点，数据处理，简单的数据可以使用 CopyOnWriteArrayList 或者 ConcurrentHashMap 。

4.客户端实现

写个简单的页面，几个按钮分别是 绑定服务端、获取数据、新增数据。
绑定服务端：用 bindService 的方式，绑定成功后将服务端返回的 Binder 转换成 aidl 接口，这样就可以调用服务端的方法了。

package com.test.relearnaidl;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.test.relearnaidl.aidl.Car;
import com.test.relearnaidl.aidl.ICarManager;
import com.test.relearnaidl.service.CarManagerService;

import java.util.List;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private Button mButtonBind, mButtonGet, mButtonAdd;

    private ICarManager carManager;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            carManager = ICarManager.Stub.asInterface(service);
            try {
                List<Car> conCar = carManager.getCarList();
                if (conCar != null && conCar.size() > 0) {
                    Log.d("luoah", "[MainActivity] -- onServiceConnected -- conCar:" + conCar.toString());
                }
            } catch (RemoteException rme) {
                rme.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mButtonBind = (Button)findViewById(R.id.button_bind);
        mButtonGet = (Button)findViewById(R.id.button_get);
        mButtonAdd = (Button)findViewById(R.id.button_add);
        mButtonBind.setOnClickListener(this);
        mButtonGet.setOnClickListener(this);
        mButtonAdd.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.button_bind:
                Intent intent = new Intent(MainActivity.this, CarManagerService.class);
                bindService(intent, mConnection, BIND_AUTO_CREATE);
                break;
            case R.id.button_get:
                try {
                    List<Car> cars = carManager.getCarList();
                    if (cars != null && cars.size() > 0) {
                        Log.d("luoah", "[MainActivity] -- onClickGet -- cars:" + cars.toString());
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.button_add:
                try {
                    carManager.addNewCar(new Car(200, "SUV 200"));
                    carManager.addNewCar(new Car(300, "SUV 300"));
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            default:break;
        }
    }

	@Override
    protected void onDestroy() {
        super.onDestroy();

        unbindService(mConnection);
    }
}

这样，客户端就可以获取和新增数据了。再来探索下监听和回调。