devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

手写一个AIDL_android aidl 手写实现

作者：从前慢现在也慢 | 2024-02-21 10:01:56

赞

踩

android aidl 手写实现

客户端demo：https://github.com/hewind/AidlClientTest

服务端demo：https://github.com/hewind/AidlServerTest

实现功能：增加人员、删除人员、获取人员信息；

一、客户端

1、创建PersonBean实体类

  1. public class PersonBean implements Parcelable {
  2.  
  3.     private String name;
  4.  
  5.     public PersonBean(String name) {
  6.         this.name = name;
  7.     }
  8.     public String getName() {
  9.         return name == null ? "" : name;
  10.     }
  11.     public void setName(String name) {
  12.         this.name = name;
  13.     }
  14.     @Override
  15.     public String toString() {
  16.         return "PersonBean{" + "name='" + name + '\'' + '}';
  17.     }
  18.  
  19.  
  20.     protected PersonBean(Parcel in) {
  21.         name = in.readString();
  22.     }
  23.     public static final Creator<PersonBean> CREATOR = new Creator<PersonBean>() {
  24.         @Override
  25.         public PersonBean createFromParcel(Parcel in) {
  26.             return new PersonBean(in);
  27.         }
  28.         @Override
  29.         public PersonBean[] newArray(int size) {
  30.             return new PersonBean[size];
  31.         }
  32.     };
  33.     @Override
  34.     public int describeContents() {
  35.         return 0;
  36.     }
  37.     @Override
  38.     public void writeToParcel(Parcel parcel, int i) {
  39.         parcel.writeString(name);
  40.     }
  41.  
  42.     //删除使用
  43.     @Override
  44.     public boolean equals(@Nullable Object obj) {
  45.         if (this == obj){//自反性
  46.             return true;
  47.         }
  48.         if (!(obj instanceof PersonBean)){//instanceof比较判断是否是同一类或者子父类关系
  49.             return false;
  50.         }
  51.         if (this.name.equals(((PersonBean) obj).getName())){//判断是同一类或者子父类关系，再将Object类型强转为Students
  52.             return true;
  53.         }
  54.         return false;
  55.     }
  56.     @Override
  57.     public int hashCode() {
  58.         return name.hashCode();
  59.     }
  60. }

PersonBean实现Parcelable接口，目的为了跨进程传输，重写equals和hashCode方法目的为了使用删除；

2、创建PersonManagerInterface接口

  1. public interface PersonManagerInterface extends IInterface {
  2.  
  3.     //添加人数
  4.     void addPerson(PersonBean personBean) throws RemoteException;
  5.  
  6.     //删除人数
  7.     void deletePerson(PersonBean personBean) throws RemoteException;
  8.  
  9.     //获取人数
  10.     List<PersonBean> getPerson() throws RemoteException;
  11. }

创建PersonManagerInterface接口，并实现IInterface接口，只有实现IInterface接口，才具备跨进程传输的基础能力，另外如果我们使用Android Studio自带的创建AIDL生成的aidl文件，也是继承了该IInterface接口，这里自己手动创建并继承效果是一样的。

3、创建Proxy代理类

  1. public class Proxy implements PersonManagerInterface {
  2.  
  3.     //远程binder对象
  4.     private IBinder iBinder;
  5.     //Binder ID
  6.     private static final String DESCRIPTOR = "com.example.aidlservertest.Proxy.PersonManagerInterface";
  7.  
  8.     public Proxy(IBinder iBinder) {
  9.         this.iBinder = iBinder;
  10.     }
  11.  
  12.     //增加人数实现
  13.     @Override
  14.     public void addPerson(PersonBean personBean) throws RemoteException {
  15.         Parcel data = Parcel.obtain();
  16.         Parcel replay = Parcel.obtain();
  17.         try {
  18.             data.writeInterfaceToken(DESCRIPTOR);
  19.             if (personBean != null){
  20.                 data.writeInt(1);
  21.                 personBean.writeToParcel(data,0);
  22.             }else {
  23.                 data.writeInt(0);
  24.             }
  25.             iBinder.transact(Stub.TRANSAVTION_addperson,data,replay,0);
  26.             replay.readException();
  27.         }finally {
  28.             replay.recycle();
  29.             data.recycle();
  30.         }
  31.     }
  32.     //删除人数实现
  33.     @Override
  34.     public void deletePerson(PersonBean personBean) throws RemoteException {
  35.         Parcel data = Parcel.obtain();
  36.         Parcel replay = Parcel.obtain();
  37.         try {
  38.             data.writeInterfaceToken(DESCRIPTOR);
  39.             if (personBean != null){
  40.                 data.writeInt(1);
  41.                 personBean.writeToParcel(data,0);
  42.             }else {
  43.                 data.writeInt(0);
  44.             }
  45.             iBinder.transact(Stub.TRANSAVTION_deleteperson,data,replay,0);
  46.             replay.readException();
  47.         }finally {
  48.             replay.recycle();
  49.             data.recycle();
  50.         }
  51.     }
  52.     //查询人数实现
  53.     @Override
  54.     public List<PersonBean> getPerson() throws RemoteException {
  55.         Parcel data = Parcel.obtain();
  56.         Parcel replay = Parcel.obtain();
  57.         List<PersonBean> result;
  58.         try {
  59.             //写入一个校验
  60.             data.writeInterfaceToken(DESCRIPTOR);
  61.             //客户端调用到这个方法，走到iBinder.transact，此时会进入系统层处理，处理结果通过调用Stub的transact方法返回，系统层处理过程会阻塞在这行代码，直到处理完成，
  62.             iBinder.transact(Stub.TRANSAVTION_getpersons,data,replay,0);
  63.             //上面一行代码在系统处理成功后，返回结果，由于Stub的transact方法写入了一个【reply.writeNoException()】，这里reply进行读取异常
  64.             replay.readException();
  65.             //这里是Stub的transact方法处理返回的结果
  66.             result = replay.createTypedArrayList(PersonBean.CREATOR);
  67.         }finally {
  68.             replay.recycle();
  69.             data.recycle();
  70.         }
  71.         return result;
  72.     }
  73.  
  74.     /**
  75.      * 方法说明：返回当前获取到的服务端的IBander
  76.      * 日期：2020-09-09 10:31
  77.      */
  78.     @Override
  79.     public IBinder asBinder() {
  80.         return iBinder;
  81.     }
  82.  
  83. }
  1. Proxy在AIDL通信中承担着发送信息的角色；
  2. Proxy实现了PersonManagerInterface接口，同时实现asBinder方法，该方法返回一个iBinder对象，该iBinder对象由Stub类实例化Proxy并传入iBinder对象；
  3. DESCRIPTOR为BinderID，一般由包名+PersonManagerInterface组成；
  4. 获取人数信息getPerson方法中data为要传送的数据，reply为接收返回的数据；data.writeInterfaceToken(DESCRIPTOR)方法为写入binderID作为校验，服务端的Stub方法收到后也会进行一个校验；接下来开始调用iBinder的transact方法，该方法会直接进入系统层处理，最终会调用到Binder驱动，然后通过Binder调用服务端的Stub的ontTransact方法建立起一个完整的沟通机制；另外在调用该方法时系统会阻塞线程进入等待，直到返回处理结果；

4、创建Stub类

  1. public abstract class Stub extends Binder implements PersonManagerInterface  {
  2.  
  3.     //Binder ID
  4.     private static final String DESCRIPTOR = "com.example.aidlservertest.Proxy.PersonManagerInterface";
  5.  
  6.     public Stub() {
  7.         //attachInterface方法：向BinderService注册Binder服务。只有注册了binder，客户端才能查询到有这个binder对象，并使用它
  8.         this.attachInterface(this,DESCRIPTOR);
  9.     }
  10.  
  11.     @Override
  12.     public IBinder asBinder() {
  13.         return this;
  14.     }
  15.  
  16.     //将服务端的Binder对象准换成客户端所需要的AIDL接口对象，
  17.     public static PersonManagerInterface asInterface(IBinder iBinder){
  18.         if ((iBinder==null)) {
  19.             return null;
  20.         }
  21.         //查询当前进程，如果客户端和服务端位于同一进程，那么此方法返回的就是当前进程的Stub对象本身，否则返回服务端进程的Stub.proxy对象（服务端也有该Stub类）
  22.         IInterface iin = iBinder.queryLocalInterface(DESCRIPTOR);
  23.         if ((iin != null) && (iin instanceof PersonManagerInterface)) {
  24.             return (PersonManagerInterface)iin;
  25.         }
  26.         //返回服务端的Stub.proxy对象
  27.         return new Proxy(iBinder);
  28.     }
  29.  
  30.     //这个方法运行在服务端中的Binder线程池当中，当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法处理。
  31.     @Override
  32.     protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
  33.         switch (code){
  34.             case INTERFACE_TRANSACTION:
  35.                 reply.writeString(DESCRIPTOR);
  36.                 return true;
  37.             case TRANSAVTION_addperson://增加人数
  38.                 //返回一个校验
  39.                 data.enforceInterface(DESCRIPTOR);
  40.                 PersonBean personBean = null;
  41.                 if (data.readInt() != 0){
  42.                     //读取PersonBean
  43.                     personBean = PersonBean.CREATOR.createFromParcel(data);
  44.                 }
  45.                 //接口方法回调出去，这里最终会走到服务端的Service类的IBinder回调中
  46.                 this.addPerson(personBean);
  47.                 //返回一个无异常
  48.                 reply.writeNoException();
  49.                 return true;
  50.             case TRANSAVTION_deleteperson://删除人数
  51.                 data.enforceInterface(DESCRIPTOR);
  52.                 PersonBean personBean2 = null;
  53.                 if (data.readInt() != 0){
  54.                     personBean2 = PersonBean.CREATOR.createFromParcel(data);
  55.                 }
  56.                 this.deletePerson(personBean2);
  57.                 reply.writeNoException();
  58.                 return true;
  59.             case TRANSAVTION_getpersons://获取人数
  60.                 data.enforceInterface(DESCRIPTOR);
  61.                 List<PersonBean> result = this.getPerson();
  62.                 reply.writeNoException();
  63.                 reply.writeTypedList(result);
  64.                 return true;
  65.         }
  66.         return super.onTransact(code, data, reply, flags);
  67.     }
  68.  
  69.     //使用int型代替字符串传递来标识调用的是哪一个方法，属于性能优化
  70.     public static final int TRANSAVTION_getpersons = IBinder.FIRST_CALL_TRANSACTION;
  71.     public static final int TRANSAVTION_addperson = IBinder.FIRST_CALL_TRANSACTION + 1;
  72.     public static final int TRANSAVTION_deleteperson = IBinder.FIRST_CALL_TRANSACTION + 2;
  73. }
  1. Stub在AIDL通信中承担着接收信息的角色；
  2. Stub类继承了Binder，同时实现了PersonManagerInterface接口；
  3. 无参构造器中，Stub类调用了一个attachInterface方法，传入了当前对象以及BinderID，该方法是向BinderService注册Binder服务，只有注册了Binder，客户端才能查询到这个Binder对象并使用它；
  4. asBinder方法返回的是当前对象，实际上跟Proxy中asBinder方法返回的是同一个Binder对象；
  5. asInterface方法是将服务端的BInder对象转换成客户端所需要的AIDL接口对象，iBinder.queryLocalInterface(DESCRIPTOR)方法会先查询一下本地进程的DESCRIPTOR是否为null，不为null的话就直接返回PersonManagerInterface接口对象；否则就实例化Proxy，并传入iBinder对象；
  6. onTransact方法即为BInder驱动处理后返回给服务端的出口，这个方法运行在服务端中的Binder线程池中，当客户端发起跨进程请求时，请求经过BInder处理，再交给该方法；
  7. 其中code参数为方法代理名称，使用数字来代替客户端想要调用的某个方法名，如果有多个方法名，会在IBinder.FIRST_CALL_TRANSACTION默认上进行加1，以此类推；

5、客户端绑定服务

  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.     private Button button,button2,button3;
  4.     private TextView textView;
  5.  
  6.     private PersonManagerInterface personManagerInterface;
  7.  
  8.     @Override
  9.     protected void onCreate(Bundle savedInstanceState) {
  10.         super.onCreate(savedInstanceState);
  11.         setContentView(R.layout.activity_main);
  12.         
  13.         prePareAidl();
  14.         
  15.         textView = findViewById(R.id.textview);
  16.         button = findViewById(R.id.button);
  17.         button2 = findViewById(R.id.button2);
  18.         button3 = findViewById(R.id.button3);
  19.         //添加人员
  20.         button.setOnClickListener(new View.OnClickListener() {
  21.             @Override
  22.             public void onClick(View view) {
  23.                 PersonBean personBean = new PersonBean();
  24.                 personBean.setName("张三");
  25.                 try {
  26.                     personManagerInterface.addPerson(personBean);
  27.                 } catch (RemoteException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.                 getPerson();
  31.             }
  32.         });
  33.         //删除人员
  34.         button2.setOnClickListener(new View.OnClickListener() {
  35.             @Override
  36.             public void onClick(View view) {
  37.                 PersonBean personBean = new PersonBean();
  38.                 personBean.setName("张三");
  39.                 try {
  40.                     personManagerInterface.deletePerson(personBean);
  41.                 } catch (RemoteException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.                 getPerson();
  45.             }
  46.         });
  47.         //获取人员
  48.         button3.setOnClickListener(new View.OnClickListener() {
  49.             @Override
  50.             public void onClick(View view) {
  51.                 getPerson();
  52.             }
  53.         });
  54.     }
  55.  
  56.     /**
  57.      * 方法说明：获取Person人数
  58.      * 日期：2020-09-11 16:36
  59.      */
  60.     private void getPerson() {
  61.         try {
  62.             List<PersonBean> list = personManagerInterface.getPerson();
  63.             String str = "";
  64.             for (PersonBean p:list){
  65.                 str += p.getName()+", ";
  66.             }
  67.             textView.setText(str);
  68.         } catch (RemoteException e) {
  69.             e.printStackTrace();
  70.         }
  71.     }
  72.  
  73.     /**
  74.      * 方法说明：通过绑定远程service，初始化远程iBinder实例
  75.      * 日期：2020-09-09 17:14
  76.      */
  77.     private void prePareAidl() {
  78.         Intent intent = new Intent();
  79.         intent.setClassName("com.example.aidlservertest","com.example.aidlservertest.Service.PersonService");
  80.         bindService(intent,MyServerConnection, Context.BIND_AUTO_CREATE);
  81.     }
  82.  
  83.     /**
  84.      * 方法说明：创建ServiceConnection
  85.      * 日期：2020-09-09 17:15
  86.      */
  87.     private ServiceConnection MyServerConnection = new ServiceConnection() {
  88.         @Override
  89.         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
  90.             System.out.println("---客户端 建立服务链接; Thread: "+Thread.currentThread().getName());
  91.             //初始化远程iBinder实例，将iBinder转成远程服务代理对象，也就是PersonManagerProxy类对象，并调用它的方法
  92.             personManagerInterface = Stub.asInterface(iBinder);
  93.         }
  94.  
  95.         @Override
  96.         public void onServiceDisconnected(ComponentName componentName) {
  97.             System.out.println("---客户端 断开服务链接; Thread: "+Thread.currentThread().getName());
  98.         }
  99.     };
  100. }
  1. 绑定服务中，Intent中传入的两个参数，一个是服务端的包名，一个是服务端Service的类路径；
  2. ServiceConnection类中onServiceConnected方法返回了一个iBinder对象，此时通过调用Stub.asInterface(iBinder)将iBInder转为服务端代理对象，也就是PersonManagerProxy接口实现类对象，并调用它的方法；

二、服务端

1、拷贝通信文件

将客户端的PersonManagerProxy、Proxy、Stub、PersonBean三个类，原封不动拷贝到服务端工程下，三个类所在目录也要同客户端一致；

2、创建Service

  1. public class PersonService extends Service {
  2.  
  3.     private List<PersonBean> list = new ArrayList<>();
  4.  
  5.     @Override
  6.     public int onStartCommand(Intent intent, int flags, int startId) {
  7.         System.out.println("---服务端 onStartCommand; Thread: "+Thread.currentThread().getName());
  8.         return super.onStartCommand(intent, flags, startId);
  9.     }
  10.  
  11.     @Nullable
  12.     @Override
  13.     public IBinder onBind(Intent intent) {
  14.         System.out.println("---服务端 onBind; Thread: "+Thread.currentThread().getName());
  15.         return mIBinder;
  16.     }
  17.  
  18.     /**
  19.      * 方法说明：
  20.      * 日期：2020-09-09 11:26
  21.      */
  22.     private IBinder mIBinder = new Stub(){
  23.         @Override
  24.         public void addPerson(PersonBean personBean) throws RemoteException {
  25.             if (personBean != null){
  26.                 list.add(personBean);
  27.             }
  28.             System.out.println("---服务端 addPerson; Thread: "+Thread.currentThread().getName()+", list: "+list);
  29.         }
  30.         @Override
  31.         public void deletePerson(PersonBean personBean) throws RemoteException {
  32.             list.remove(personBean);
  33.             System.out.println("---服务端 deletePerson; Thread: "+Thread.currentThread().getName()+", list: "+list);
  34.         }
  35.         @Override
  36.         public List<PersonBean> getPerson() throws RemoteException {
  37.             System.out.println("---服务端 getPerson; Thread: "+Thread.currentThread().getName()+", list: "+list);
  38.             return list;
  39.         }
  40.     };
  41. }
  1. Service类中的onBind方法返回了一个IBinder对象，这里在Service类中实例化一个Stub对象，因为Stub继承了Binder，同时实现增加、删除、查询方法，在这三个方法中进行实现相应的功能，客户端通过Proxy——>Binder.transact——>Binder驱动——>服务端Stub.onTransact——服务端new Stub；形成一个完整的通信机制

3、服务端开启服务

  1. public class MainActivity extends AppCompatActivity {
  2.  
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) {
  5.         super.onCreate(savedInstanceState);
  6.         setContentView(R.layout.activity_main);
  7.  
  8.         startService(new Intent(this, PersonService.class));
  9.     }
  10. }

使用startService开启服务；

4、注册服务

  1. <service android:name="com.example.aidlservertest.Service.PersonService"
  2.                 android:enabled="true"
  3.                 android:exported="true"/>

到此整个手动创建AIDL工程已经结束，测试的时候，需要先运行服务端，再运行客户端；

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号