Android Aidl的使用

已于 2024-03-08 14:41:08 修改
阅读量78 收藏
点赞数
文章标签： android
于 2024-03-08 14:36:59 首次发布
原文链接：https://blog.csdn.net/weixin_44021334/article/details/114933298
版权

一.准备

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

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

本例包名：com.test.relearnaidl

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

Aidl 支持的数据类型有：

  • 八种基本数据类型：byte、char、short、int、long、float、double、boolean
  • String，CharSequence
  • 实现了Parcelable接口的数据类型
  • List类型。List承载的数据必须是AIDL支持的类型，或者是其它声明的AIDL对象
  • Map类型。Map承载的数据必须是AIDL支持的类型，或者是其它声明的AIDL对象

AIDL参数TAG 有  in、out、inout 三种,基本类型默认为in,自定义类型需显示声明

  • 当out时,需要空参数构造方法
  • 当 out或inout 时,自定义类型需手动实现

public void readFromParcel(Parcel desc) {
        name = desc.readString();
}
 

实际开发中，我们要传入的数据可能是 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);
    }
}

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

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 接口，这样就可以调用服务端的方法了。


这样，客户端就可以获取和新增数据了。

客户端监听数据变化

如服务端数据有更新，客户端怎么及时知道呢，来探索下。

流程为：

  • 1.新增一个 aidl 接口；
  • 2.服务端修改；
  • 3.客户端注册监听。

1.新增一个 aidl 接口

首先，在 aidl 文件夹下新建一个 aidl 文件 IOnNewCarAddListener.aidl ，

package com.test.relearnaidl.aidl;

import com.test.relearnaidl.aidl.Car;

interface IOnNewCarAddListener{
    void onNewCarAdd(in Car newCar);
}

然后修改 ICarManager.aidl ，添加两个方法

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

import com.test.relearnaidl.aidl.Car;
import com.test.relearnaidl.aidl.IOnNewCarAddListener;
// 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);
    void registerListener(IOnNewCarAddListener listener);
    void unregisterListener(IOnNewCarAddListener listener);
}

2.服务端修改

修改的不多，主要是为了适配新加的接口。

  • mBinder 对象实现新增的接口；
  • 新增一个列表 mListenerList 存储注册的监听器，数据变化时通知到 mListenerList 里所有的 listenerList ；
  • 添加一个 addRunnable 模拟数据变化。

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 android.util.Log;

import androidx.annotation.Nullable;

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

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

public class CarManagerService extends Service {

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

    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);
            onNewCarAdd(car);
        }

        @Override
        public void registerListener(IOnNewCarAddListener listener) throws RemoteException {
            if (!mListenerList.contains(listener)) {
                mListenerList.add(listener);
            } else {
                Log.d("luoah", "[CarManagerService] -- registerListener -- this listener already exist");
            }
        }

        @Override
        public void unregisterListener(IOnNewCarAddListener listener) throws RemoteException {
            if (mListenerList.contains(listener)) {
                mListenerList.remove(listener);
            } else {
                Log.d("luoah", "[CarManagerService] -- unregisterListener -- listener not found");
            }
        }
    };

    private void onNewCarAdd(Car car) throws RemoteException{
        mCarList.add(car);
        for (int j = 0; j < mListenerList.size(); j++){
            IOnNewCarAddListener listener = mListenerList.get(j);
            listener.onNewCarAdd(car);
        }
    }

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

    @Override
    public void onCreate() {
        super.onCreate();
        mCarList.add(new Car(100, "SUV_100"));
        new Thread(new addRunnable()).start();
    }

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

    private class addRunnable implements Runnable{

        @Override
        public void run() {
            try{
                Thread.sleep(3000);
            } catch (InterruptedException ie){
                ie.printStackTrace();
            }
            try {
                Car bcar = new Car(700, "BM_700");
                onNewCarAdd(bcar);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }
}

3.客户端修改

成功连接后注册 IOnNewCarAddListener ，退出时反注册。和广播很像。

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.aidl.IOnNewCarAddListener;
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());
                }

                carManager.registerListener(clientListener);
            } catch (RemoteException rme) {
                rme.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            try {
                carManager.unregisterListener(clientListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    private IOnNewCarAddListener clientListener = new IOnNewCarAddListener.Stub() {
        @Override
        public void onNewCarAdd(Car newCar) throws RemoteException {
            Log.d("luoah", "[MainActivity] -- onNewCarAdd -- newCar:" + newCar.toString());
        }
    };

    @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();
        if (carManager != null
            && carManager.asBinder().isBinderAlive()) {
            try {
                carManager.unregisterListener(clientListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        unbindService(mConnection);
    }
}

这样，当数据变化时，客户端就可以收到消息了。

But ，按返回键退出应用，log 是

com.test.relearnaidl D/luoah: [CarManagerService] -- unregisterListener -- listener not found

不是同一个 listener 吗，怎么找不到 ？

原因如下，摘抄自 《Android开发艺术探索》

多进程无法奏效，因为 Binder 会把客户端传过来的对象重新转化成一个新的对象。虽然注册和解注册过程中使用的是同一个客户端对象，但是通过 Binder 传递到服务端后，却会产生两个全新的对象。别忘了对象是不能跨进程传递的，对象的跨进程传递本质上是反序列化的过程，这就是为什么 AIDL 中的自定义对象都必须要实现 Parcelable 接口。

 解决这个问题，用 RemoteCallbackList 。

正确添加移除监听

用 RemoteCallbackList 来正确移除注册到服务端的 listener 。
客户端不用修改，修改服务端。

  1. 使用 RemoteCallbackList 代替 CopyOnWriteArrayList ；
  2. 修改注册、反注册方法；
  3. 修改通知 listener 的方法。

1.使用 RemoteCallbackList 代替 CopyOnWriteArrayList

private RemoteCallbackList<IOnNewCarAddListener> mRemoteCallbackList = new RemoteCallbackList<IOnNewCarAddListener>();

 2.修改注册、反注册方法；

@Override
        public void registerListener(IOnNewCarAddListener listener) throws RemoteException {
            mRemoteCallbackList.register(listener);
            /*if (!mListenerList.contains(listener)) {
                mListenerList.add(listener);
            } else {
                Log.d("luoah", "[CarManagerService] -- registerListener -- this listener already exist");
            }*/
        }

        @Override
        public void unregisterListener(IOnNewCarAddListener listener) throws RemoteException {
            mRemoteCallbackList.unregister(listener);
            /*if (mListenerList.contains(listener)) {
                mListenerList.remove(listener);
            } else {
                Log.d("luoah", "[CarManagerService] -- unregisterListener -- listener not found");
            }*/
        }

3.修改通知 listener 的方法

private void onNewCarAdd(Car car) throws RemoteException{
        mCarList.add(car);
        /*for (int j = 0; j < mListenerList.size(); j++){
            IOnNewCarAddListener listener = mListenerList.get(j);
            listener.onNewCarAdd(car);
        }*/
        int t = mRemoteCallbackList.beginBroadcast();
        for (int j = 0; j < t; j++){
            IOnNewCarAddListener listener = mRemoteCallbackList.getBroadcastItem(j);
            if (listener != null) {
                try{
                    listener.onNewCarAdd(car);
                } catch (RemoteException e){
                    e.printStackTrace();
                }
            }
        }
        mRemoteCallbackList.finishBroadcast();
    }

再添加了权限判断，没权限的客户端无法获取到 Binder。
注册文件添加权限，

<permission android:name="com.test.relearnaidl.permision.ACCESS_CAR_DATA"
        android:protectionLevel="normal"/>

服务端 onBind 方法中判断权限，

	@Nullable
    @Override
    public IBinder onBind(Intent intent) {
        int ticket = checkCallingPermission("com.test.relearnaidl.permision.ACCESS_CAR_DATA");
        if (ticket == PackageManager.PERMISSION_DENIED) {
            return null;
        }

        return mBinder;
    }

附上终版源码，方便以后查阅。

工程目录

1.AIDL

ICarManager.aidl

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

import com.test.relearnaidl.aidl.Car;
import com.test.relearnaidl.aidl.IOnNewCarAddListener;
// 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);
    void registerListener(IOnNewCarAddListener listener);
    void unregisterListener(IOnNewCarAddListener listener);
}

Car.aidl

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

IOnNewCarAddListener.aidl

package com.test.relearnaidl.aidl;

import com.test.relearnaidl.aidl.Car;

interface IOnNewCarAddListener{
    void onNewCarAdd(in Car newCar);
}

2.服务端

CarManagerService.java

package com.test.relearnaidl.service;

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

import androidx.annotation.Nullable;

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

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

public class CarManagerService extends Service {

    private CopyOnWriteArrayList<Car> mCarList = new CopyOnWriteArrayList<Car>();
    private CopyOnWriteArrayList<IOnNewCarAddListener> mListenerList = new CopyOnWriteArrayList<IOnNewCarAddListener>();
    private RemoteCallbackList<IOnNewCarAddListener> mRemoteCallbackList = new RemoteCallbackList<IOnNewCarAddListener>();


    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);
            onNewCarAdd(car);
        }

        @Override
        public void registerListener(IOnNewCarAddListener listener) throws RemoteException {
            mRemoteCallbackList.register(listener);
            /*if (!mListenerList.contains(listener)) {
                mListenerList.add(listener);
            } else {
                Log.d("luoah", "[CarManagerService] -- registerListener -- this listener already exist");
            }*/
        }

        @Override
        public void unregisterListener(IOnNewCarAddListener listener) throws RemoteException {
            mRemoteCallbackList.unregister(listener);
            /*if (mListenerList.contains(listener)) {
                mListenerList.remove(listener);
            } else {
                Log.d("luoah", "[CarManagerService] -- unregisterListener -- listener not found");
            }*/
        }
    };

    private void onNewCarAdd(Car car) throws RemoteException{
        mCarList.add(car);
        /*for (int j = 0; j < mListenerList.size(); j++){
            IOnNewCarAddListener listener = mListenerList.get(j);
            listener.onNewCarAdd(car);
        }*/
        int t = mRemoteCallbackList.beginBroadcast();
        for (int j = 0; j < t; j++){
            IOnNewCarAddListener listener = mRemoteCallbackList.getBroadcastItem(j);
            if (listener != null) {
                try{
                    listener.onNewCarAdd(car);
                } catch (RemoteException e){
                    e.printStackTrace();
                }
            }
        }
        mRemoteCallbackList.finishBroadcast();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
    	int ticket = checkCallingPermission("com.test.relearnaidl.permision.ACCESS_CAR_DATA");
        if (ticket == PackageManager.PERMISSION_DENIED) {
            return null;
        }
        
        return mBinder;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("luoah", "[CarManagerService] -- onCreate -- ");
        mCarList.add(new Car(100, "SUV_100"));
        new Thread(new addRunnable()).start();
    }

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

    private class addRunnable implements Runnable{

        @Override
        public void run() {
            try{
                Thread.sleep(3000);
            } catch (InterruptedException ie){
                ie.printStackTrace();
            }
            try {
                Car bcar = new Car(700, "BM_700");
                onNewCarAdd(bcar);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }
}

3.客户端

客户端 MainActivity.java 。
目前都是在主线程操作的，实际使用的话，还是用 Handler 等方式来获取数据比较好，防止出现超时出现 ANR 等情况。

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.aidl.IOnNewCarAddListener;
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());
                }

                carManager.registerListener(clientListener);
            } catch (RemoteException rme) {
                rme.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            try {
                carManager.unregisterListener(clientListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    private IOnNewCarAddListener clientListener = new IOnNewCarAddListener.Stub() {
        @Override
        public void onNewCarAdd(Car newCar) throws RemoteException {
            Log.d("luoah", "[MainActivity] -- onNewCarAdd -- newCar:" + newCar.toString());
        }
    };

    @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();
        if (carManager != null
            && carManager.asBinder().isBinderAlive()) {
            try {
                carManager.unregisterListener(clientListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        unbindService(mConnection);
    }
}

4.数据

就是 Car 类了

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);
    }
}

5.注册文件和布局文件

注册文件

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    package="com.test.relearnaidl">
	
	<permission android:name="com.test.relearnaidl.permision.ACCESS_CAR_DATA"
        android:protectionLevel="normal"/>

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

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

</manifest>

布局文件

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/button_bind"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="bind servcie"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.625" />

    <Button
        android:id="@+id/button_get"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="get car list"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintHorizontal_bias="0.498"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.733" />

    <Button
        android:id="@+id/button_add"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="add new Car"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.838" />

</androidx.constraintlayout.widget.ConstraintLayout>

使用linkToDeath对AIDL双向死亡监听

概述

   在使用service中进行AIDL交互时候，如果服务端或者客户端意外停止，会抛出异常android.os.DeadObjectException ， 这时候我们就需要双向监听服务端和客户端的异常停止，并重新绑定服务

linkToDeath的使用 

  linkToDeath 为Binder对象添加死亡代理。
  unlinkToDeath 取消死亡代理

客户端
 

首先我们需要创建一个DeathRecipient对象

    private IBinder.DeathRecipient mDeathProxy = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            //监听死亡，重新绑定
            Log.d("zkq", "服务端崩溃，需要重新绑定");
            mBinder.asBinder().unlinkToDeath(mDeathProxy, 0);
        }
    };

在service绑定成功以后，给服务绑定死亡代理 ，当服务端异常停止以后，我们会收到binderDied回调，并在这里重新绑定服务

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder iBinder) {
            Log.d("zkq", " onServiceConnected =  " + iBinder);
            mBinder = IMyAidlInterface.Stub.asInterface(iBinder);
            try {
                mBinder.asBinder().linkToDeath(mDeathProxy, 0);
            }catch (RemoteException e){
                Log.e("zkq", "onServiceConnected: linkToDeath error");
            }
            try {
                mBinder.setCallback(mICallBack);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
 
        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("zkq", " onServiceDisconnected =  " + name);
        }
    };

绑定服务

    private void bind() {
        Intent intent = new Intent();
        intent.setAction(MyService.ACTION);
        intent.setPackage(getPackageName());
        boolean ret = bindService(intent, conn, Context.BIND_AUTO_CREATE);
        Log.d("zkq", " ret =  " + ret);
    }
服务端

相应的在服务端，添加客户端的死亡监听，我们只需要在binderDied中，移除客户端的回调

    IMyAidlInterface.Stub myAidlInterface = new IMyAidlInterface.Stub() {
        @Override
        public void setCallback(ICallBack var1) throws RemoteException {
            var1.asBinder().linkToDeath(new DeathRecipient() {
                @Override
                public void binderDied() {
                    Log.d("zkq","客户端崩溃，移除回调");
                    mBinder.asBinder().unlinkToDeath(this, 0);
                }
            },0);
        }
    };

完整服务端代码如下：

public class MyService extends Service {
 
    public static final String ACTION = "com.zkq.autofly.action.START_SERVICE";
    IMyAidlInterface mBinder;
 
    public MyService() {
    }
 
 
    IMyAidlInterface.Stub myAidlInterface = new IMyAidlInterface.Stub() {
        @Override
        public void setCallback(ICallBack var1) throws RemoteException {
            var1.asBinder().linkToDeath(new DeathRecipient() {
                @Override
                public void binderDied() {
                    Log.d("zkq","客户端崩溃，需要重新绑定");
                }
            },0);
        }
    };
 
    @Override
    public IBinder onBind(Intent intent) {
        if (intent.getAction().equals(ACTION)) {
            return myAidlInterface;
        }
        return null;
    }
}

一叶飘舟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
php时间人性化展示
赛时科技
04-22 140
函数，用于将时间戳转换为人性化的时间差。该函数遍历了不同的时间单位，找到合适的单位来表示时间差，并返回相应的字符串。这样，你就可以根据需要将时间以人性化的方式展示给用户了。你可以根据具体需求调整时间格式和单位。函数将其格式化为"年-月-日 时:分:秒"的形式。然后，我们定义了一个。在上面的示例中，我们首先获取了当前的时间戳，并使用。函数来实现时间的人性化展示。函数将"-2 days"转换为时间戳），然后调用。最后，我们假设有一个过去的时间戳（这里使用。函数将其转换为人性化的时间差，并输出结果。
Android Binder——APP中AIDL解析（二十）
小旭的专栏
04-23 106
一个从 Client 到 Server 的调用流程总结如下：通过 bindService() 让 Zygote 进程 fork 出 Server 进程，完成 Server 进程的初始化功能加载。同时建立 Client 和 Server 的关系；
AndroidAIDL
12-07
使用AIDL实现Android进程间通信，Demo包含Service，Client代码。
Android aidl使用示例源码
05-04
aidl文件的创建，service文件的创建，aidl通信的演示，服务的绑定
Android AIDL使用例子
05-30
Android AIDL使用例子
Android AIDL使用详解
04-21
NULL 博文链接：https://iaiai.iteye.com/blog/1928276
详解Android aidl的使用方法
01-03
AIDL是Android中IPC（Inter-Process Communication）方式中的一种，AIDL是Android Interface definition language的缩写（对于小白来说，AIDL的作用是让你可以在自己的APP里绑定一个其他APP的service，这样你的APP可以和其他APP交互。） AIDL只是Android中众多进程间通讯方式中的一种方式， AIDL和Messenger的区别： Messenger不适用大量并发的请求：Messenger以串行的方式来处理客户端发来的消息，如果大量的消息同时发送到服务端，服务端仍然只能一个个的去处理。 Mess
Android AIDL使用
u012514113的专栏
03-07 1873
Android 接口定义语言 (AIDL) AIDL语法
Android AIDL使用示例
wolf0706的专栏
03-15 423
AIDL主要用于跨进程通信，比如经常会有其它App需要和我们的App进行通信的需求，这个时候就需要使用AIDL。
android aidl使用demo
hello PHP的博客
12-14 945
android aidl
Android AIDL使用解析
j086924的专栏
04-07 2717
一.Android AIDL介绍 1.AIDL 即 Android Interface Definition Language，android接口定义语言，，是用于定义服务器和客户端通信接口的一种描述语言，可以拿来生成用于IPC的代码，一般暴露方法给其他应用进行调用的应用称为服务端（server），调用其他应用的方法的应用称为客户端(client)，客户端通过绑定服务端的Service来进行交互。 2.AIDL的语法,aidl 文件以.aidl为后缀名，支持的数据类型分为如下几种： 1).八种基本数据类
Android --- 英文单引号用&apos；替换报错：does not contain a valid string resource
梁同学与Android
04-23 185
Android --- 英文单引号用&apos;替换报错：does not contain a valid string resource
安卓aab文件生成apk文件
ma15991375491的博客
04-24 286
比如我们在手机上经常下载的的各种APP，其实一个Android应用程序的代码想要在Android设备上运行，必须先进行编译，然后被打包成为一个被Android系统所能识别的文件才可以被运行，而这种能被Android系统识别并运行的文件格式便是“APK”。一个APK文件内包含被编译的代码文件(.dex 文件)，文件资源（resources）， 原生资源文件（assets），证书（certificates），和清单文件（manifest file）严格来说，两者没有什么区别，后者是前者的一种升级版格式文件。
bugku ezbypass
m_de_g的博客
04-23 184
bugku ezbypass $++,$_++
OceanBase OLAP collation utf8mb4_bin 优先
余璜的技术博客
04-23 354
utf8mb4_bin是一种二进制的排序规则，比较字符串时直接比较字符串的二进制值，不需要进行复杂的字符比较和排序运算，这样可以有效减少CPU的使用，提高查询效率，特别是在涉及到大量数据操作时，性能优势更为明显。在大数据系统中，如无特别需要，建议 collation 指定为 utf8mb4_bin。
TP8 利用jwt 生成token
m0_69254007的博客
04-26 179
使用Composer安装依赖库，终端切换到项目根目录输入如下。
Android 分享页面下载app后 自动填充邀请码
最新发布
qq_21467035的博客
04-26 120
android 分享出去h5页面，通过页面下载对应包，安装启动登录注册时候，需要自动填写邀请码，一般情况下，我们需要将分享人信息写入app包中，这样下载时候根据这个信息可以获取到对应安装包。android我们可以把信息写入assets文件夹下，打包时候assets不会被编译。所以在app安装后，只需要读取对应assets文件，获取对应邀请码。当用户点击邀请时候，我们告诉后台生成对应app包。被邀请用户点击下载时候，下载指定app包实现，邀请码自动填充。
BUUCTF中的web
2401_82388450的博客
04-22 749
1.先上传一个一句话木马的php文件，提示可以上传的文件类型。2.上传一个图片文件，抓包之后，修改文件后缀名。参数可能用于告诉服务器要加载或处理哪个文件。3.上传成功，用蚁剑连接，找到flag。注意要空一格，发现上传成功。
「PHP系列」PHP 发送电子邮件详解
日常笔记/总结/系列知识梳理
04-24 1055
此外，如果你想要更多的控制和灵活性，你也可以使用第三方库，如 PHPMailer 或 SwiftMailer。函数发送邮件可能会受到一些限制，如发送频率、邮件大小等。此外，由于它依赖于服务器上的邮件发送工具，因此可能会受到服务器配置的影响。函数在发送邮件时依赖于服务器上的邮件发送工具（如 sendmail），因此，你可能需要确保你的服务器已经配置好了邮件发送功能。然后，我们指定了发件人和收件人的邮箱和名称，设置了邮件的主题和内容，最后调用了。如果邮件发送成功，将输出“邮件发送成功”，否则将输出错误信息。
android aidl使用
05-26
Android AIDL（Android Interface Definition Language）是一种用于定义客户端和服务之间通信接口的语言。AIDL 是一个 Android 特有的 RPC（远程过程调用）机制。 下面是使用 AIDL 的基本步骤： 1. 定义 AIDL 接口 在服务端创建一个 AIDL 文件，定义服务的接口方法。例如，创建一个名为 IMyService.aidl 的文件，其中包含以下内容： ``` interface IMyService { void sayHello(); } ``` 2. 实现 AIDL 接口 在服务端实现 AIDL 接口，例如： ``` public class MyService extends Service { private final IMyService.Stub binder = new IMyService.Stub() { @Override public void sayHello() throws RemoteException { Log.i("MyService", "Hello World"); } }; @Nullable @Override public IBinder onBind(Intent intent) { return binder; } } ``` 3. 绑定服务 在客户端绑定服务，例如： ``` private ServiceConnection connection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { IMyService myService = IMyService.Stub.asInterface(service); try { myService.sayHello(); } catch (RemoteException e) { e.printStackTrace(); } } @Override public void onServiceDisconnected(ComponentName name) { } }; private void bindService() { Intent intent = new Intent(this, MyService.class); bindService(intent, connection, Context.BIND_AUTO_CREATE); } ``` 通过上述步骤，就可以实现客户端与服务端之间的通信。需要注意的是，AIDL 接口中定义的方法必须是可序列化的。如果方法参数或返回值类型不支持序列化，可以通过 Parcelable 接口实现序列化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值