devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 进程间通信机制(六) 手写AIDL文件

作者：菜鸟追梦旅行 | 2024-02-21 09:59:34

赞

踩

手写aidl

  阅读本篇文章前, 请先查看一下笔者之前的写的两篇博客文章: Android Service知识  和  Android AIDL使用

        进程间通信涉及到客户端和服务端, 肯定有绑定服务的过程, 所以要阅读一下Android Service相关的知识,   跨进程通信的媒介aidl文件,我们也必须要了解怎么创建的,有什么规则,所以请先阅读一下Android AIDL使用这篇文章.

一. 概述

      

       本文重点讲解一下AIDL文件结构以及类中每个方法的含义.  然后把AIDL中每个方法的用途理解清楚后, 我们就不依赖AS自带的工具创建, 而是自己手动去写一个AIDL文件, 在手写的代码中添加自己的日志, 根据打印理清楚客户端与服务端跨进程通信的流程图, 目的加深对IPC机制的理解.

二. AIDL文件结构

 这是我创建的一个 IStudentService.aidl   里面有三个方法,然后build一下,系统自动为我们生成一个IStudentService.java类. 先大致看一下类结构和方法:

  1. public interface IStudentService extends android.os.IInterface {
  2.     /**
  3.      * Default implementation for IStudentService.
  4.      */
  5.     public static class Default implements com.example.mysevicejava.IStudentService {
  6.         /**
  7.          * Demonstrates some basic types that you can use as parameters
  8.          * and return values in AIDL.
  9.          *///定向tag
  10.         @Override
  11.         public java.lang.String getString() throws android.os.RemoteException {
  12.             return null;
  13.         }
  14.  
  15.         @Override
  16.         public void addStudent(com.example.mysevicejava.Student student) throws android.os.RemoteException {
  17.         }
  18.         //void test(in PathParceTest obb);
  19.  
  20.         @Override
  21.         public java.util.List<com.example.mysevicejava.Student> getStudentList() throws android.os.RemoteException {
  22.             return null;
  23.         }
  24.  
  25.         @Override
  26.         public android.os.IBinder asBinder() {
  27.             return null;
  28.         }
  29.     }
  30.  
  31.     /**
  32.      * Local-side IPC implementation stub class.
  33.      * 1. Stub是一个抽象类 最终的实现是在service中.
  34.      * 2. 同时继承拓展了android.os.Binder.
  35.      * 3. Stub 是 IStudentService接口的具体实现类.
  36.      */
  37.     public static abstract class Stub extends android.os.Binder implements com.example.mysevicejava.IStudentService {
  38.         private static final java.lang.String DESCRIPTOR = "com.example.mysevicejava.IStudentService";
  39.  
  40.         /**
  41.          * Construct the stub at attach it to the interface.
  42.          */
  43.         public Stub() {
  44.             this.attachInterface(this, DESCRIPTOR);
  45.         }
  46.  
  47.         /**
  48.          * Cast an IBinder object into an com.example.mysevicejava.IStudentService interface,
  49.          * generating a proxy if needed.
  50. 这个是方法是在静态抽象类 Stub中,  作用: 用于服务端的Binder对象转换成客户端所需的AIDL接口类型的对象, 此转换过程是区分进程的,如果Client 和 Service端在统一进程中, 那么此方法返回的就是服务端的Stub对象本身, 如果是跨进程的话, 则返回的是Stub.proxy对象.
  51.          */
  52.         public static com.example.mysevicejava.IStudentService asInterface(android.os.IBinder obj) {
  53.             if ((obj == null)) {
  54.                 return null;
  55.             }
  56.             android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
  57.             if (((iin != null) && (iin instanceof com.example.mysevicejava.IStudentService))) {
  58.                 return ((com.example.mysevicejava.IStudentService) iin);
  59.             }
  60.             return new com.example.mysevicejava.IStudentService.Stub.Proxy(obj);
  61.         }
  62.  
  63.         @Override
  64.         public android.os.IBinder asBinder() {
  65.             return this;
  66.         }
  67.  
  68.         @Override
  69.         public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
  70.             java.lang.String descriptor = DESCRIPTOR;
  71.             switch (code) {
  72.                 case INTERFACE_TRANSACTION: {
  73.                     reply.writeString(descriptor);
  74.                     return true;
  75.                 }
  76.                 case TRANSACTION_getString: {
  77.                     data.enforceInterface(descriptor);
  78.                     java.lang.String _result = this.getString();
  79.                     reply.writeNoException();
  80.                     reply.writeString(_result);
  81.                     return true;
  82.                 }
  83.                 case TRANSACTION_addStudent: {
  84.                     data.enforceInterface(descriptor);
  85.                     com.example.mysevicejava.Student _arg0;
  86.                     if ((0 != data.readInt())) {
  87.                         _arg0 = com.example.mysevicejava.Student.CREATOR.createFromParcel(data);
  88.                     } else {
  89.                         _arg0 = null;
  90.                     }
  91.                     this.addStudent(_arg0);
  92.                     reply.writeNoException();
  93.                     return true;
  94.                 }
  95.                 case TRANSACTION_getStudentList: {
  96.                     data.enforceInterface(descriptor);
  97.                     java.util.List<com.example.mysevicejava.Student> _result = this.getStudentList();
  98.                     reply.writeNoException();
  99.                     reply.writeTypedList(_result);
  100.                     return true;
  101.                 }
  102.                 default: {
  103.                     return super.onTransact(code, data, reply, flags);
  104.                 }
  105.             }
  106.         }
  107.  
  108.         private static class Proxy implements com.example.mysevicejava.IStudentService {
  109.             private android.os.IBinder mRemote;
  110.  
  111.             Proxy(android.os.IBinder remote) {
  112.                 mRemote = remote;
  113.             }
  114.  
  115.             @Override
  116.             public android.os.IBinder asBinder() {
  117.                 return mRemote;
  118.             }
  119.  
  120.             public java.lang.String getInterfaceDescriptor() {
  121.                 return DESCRIPTOR;
  122.             }
  123.  
  124.             /**
  125.              * Demonstrates some basic types that you can use as parameters
  126.              * and return values in AIDL.
  127.              *///定向tag
  128.             @Override
  129.             public java.lang.String getString() throws android.os.RemoteException {
  130.                 android.os.Parcel _data = android.os.Parcel.obtain();
  131.                 android.os.Parcel _reply = android.os.Parcel.obtain();
  132.                 java.lang.String _result;
  133.                 try {
  134.                     _data.writeInterfaceToken(DESCRIPTOR);
  135.                     boolean _status = mRemote.transact(Stub.TRANSACTION_getString, _data, _reply, 0);
  136.                     if (!_status && getDefaultImpl() != null) {
  137.                         return getDefaultImpl().getString();
  138.                     }
  139.                     _reply.readException();
  140.                     _result = _reply.readString();
  141.                 } finally {
  142.                     _reply.recycle();
  143.                     _data.recycle();
  144.                 }
  145.                 return _result;
  146.             }
  147.  
  148.             @Override
  149.             public void addStudent(com.example.mysevicejava.Student student) throws android.os.RemoteException {
  150.                 android.os.Parcel _data = android.os.Parcel.obtain();
  151.                 android.os.Parcel _reply = android.os.Parcel.obtain();
  152.                 try {
  153.                     _data.writeInterfaceToken(DESCRIPTOR);
  154.                     if ((student != null)) {
  155.                         _data.writeInt(1);
  156.                         student.writeToParcel(_data, 0);
  157.                     } else {
  158.                         _data.writeInt(0);
  159.                     }
  160.                     boolean _status = mRemote.transact(Stub.TRANSACTION_addStudent, _data, _reply, 0);
  161.                     if (!_status && getDefaultImpl() != null) {
  162.                         getDefaultImpl().addStudent(student);
  163.                         return;
  164.                     }
  165.                     _reply.readException();
  166.                 } finally {
  167.                     _reply.recycle();
  168.                     _data.recycle();
  169.                 }
  170.             }
  171.             //void test(in PathParceTest obb);
  172.  
  173.             @Override
  174.             public java.util.List<com.example.mysevicejava.Student> getStudentList() throws android.os.RemoteException {
  175.                 android.os.Parcel _data = android.os.Parcel.obtain();
  176.                 android.os.Parcel _reply = android.os.Parcel.obtain();
  177.                 java.util.List<com.example.mysevicejava.Student> _result;
  178.                 try {
  179.                     _data.writeInterfaceToken(DESCRIPTOR);
  180.                     boolean _status = mRemote.transact(Stub.TRANSACTION_getStudentList, _data, _reply, 0);
  181.                     if (!_status && getDefaultImpl() != null) {
  182.                         return getDefaultImpl().getStudentList();
  183.                     }
  184.                     _reply.readException();
  185.                     _result = _reply.createTypedArrayList(com.example.mysevicejava.Student.CREATOR);
  186.                 } finally {
  187.                     _reply.recycle();
  188.                     _data.recycle();
  189.                 }
  190.                 return _result;
  191.             }
  192.  
  193.             public static com.example.mysevicejava.IStudentService sDefaultImpl;
  194.         }
  195.  
  196.         static final int TRANSACTION_getString = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
  197.         static final int TRANSACTION_addStudent = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
  198.         static final int TRANSACTION_getStudentList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
  199.  
  200.         public static boolean setDefaultImpl(com.example.mysevicejava.IStudentService impl) {
  201.             if (Stub.Proxy.sDefaultImpl == null && impl != null) {
  202.                 Stub.Proxy.sDefaultImpl = impl;
  203.                 return true;
  204.             }
  205.             return false;
  206.         }
  207.  
  208.         public static com.example.mysevicejava.IStudentService getDefaultImpl() {
  209.             return Stub.Proxy.sDefaultImpl;
  210.         }
  211.     }
  212.  
  213.     /**
  214.      * Demonstrates some basic types that you can use as parameters
  215.      * and return values in AIDL.
  216.      *///定向tag
  217.     public java.lang.String getString() throws android.os.RemoteException;
  218.  
  219.     public void addStudent(com.example.mysevicejava.Student student) throws android.os.RemoteException;
  220.     //void test(in PathParceTest obb);
  221.  
  222.     public java.util.List<com.example.mysevicejava.Student> getStudentList() throws android.os.RemoteException;
  223. }

根据类结构图, 其实我们只需要搞明白这2个核心实现方法

1. 静态抽象类 Stub;

2. Stub的静态内部类Proxy ;

Question:  写到这里,提个问题,就是google工程师为什么要把 Stub类设计为抽象类啊?

Answer:   Stub类extends  android.os.Binder  并且 implement 你自定义的AIDL文件中的方法,  它的最终实现是在你的service代码中,  人家google工程师他们只能帮你把模板搭建好, 具体的业务逻辑肯定是自己去实现了.

在服务端中继承IStudentService.Stub这个抽象类, 并在 onBind回调方法中返回IBinder对象

  1.     class MyBinder extends IStudentService.Stub{
  2.  
  3.         @Override
  4.         public String getString() throws RemoteException {
  5.             return "我是从服务端返回的数据:  111";
  6.         }
  7.  
  8.         @Override
  9.         public void addStudent(Student student) throws RemoteException {
  10.             mStudentList.add(student);
  11.         }
  12.  
  13.         @Override
  14.         public List<Student> getStudentList() throws RemoteException {
  15.             return mStudentList;
  16.         }
  17.     }
  18.  
  19.     @Override
  20.     public IBinder onBind(Intent intent) {
  21.         Log.e("test", "==服务端==onBind========");
  22.         // TODO: Return the communication channel to the service.
  23.         return new MyBinder();
  24.     }

这个IBinder对象对应的就是客户端中 IBinder  service对象.

public void onServiceConnected(ComponentName componentName, IBinder service)

我们逐个来解析:

public interface IStudentService extends android.os.IInterface

2.1  首先IStudentService.java类继承与 IInterface这个接口

  1. package android.os;
  2.  
  3. /**
  4.  * Base class for Binder interfaces.  When defining a new interface,
  5.  * you must derive it from IInterface.
  7.     Binder接口的基类。当定义新接口时，你必须继承它。
  8.  */
  9. public interface IInterface
  10. {
  11.     /**
  12.      * Retrieve the Binder object associated with this interface.
  13.      * You must use this instead of a plain cast, so that proxy objects
  14.      * can return the correct result.
  16.     检索与此接口关联的Binder对象。
  18.     必须使用此方法转换，这样代理对象才能返回正确的结果
  20.      */
  21.     public IBinder asBinder();
  22. }

同时它自己也是一个接口, 所有可以在Binder中传输的接口都需要继承IInterface接口, 那么如果要自定义手写AIDL的话, 我们当然必须继承IInterface接口, 好到这里提炼第一条规则出来.

2.2  Binder的唯一标识, 一般用当前Binder的类名表示.

为了一个Binder和一个特定服务接口绑定，以对外提供功能，需要给Binder定义一个DESCRIPTOR描述，表示我这个Binder是提供特定功能链接的，不是随便可以用的。

通常，DESCRIPTOR描述会直接使用包名 + 服务接口。

private static final java.lang.String DESCRIPTOR = "com.example.mysevicejava.IStudentService";

2.3   asInterface(android.os.IBinder obj)

        这个是方法是在静态抽象类 Stub中,  作用: 用于服务端的Binder对象转换成客户端所需的AIDL接口类型的对象, 此转换过程是区分进程的,如果Client 和 Service端在统一进程中, 那么此方法返回的就是服务端的Stub对象本身, 如果是跨进程的话, 则返回的是Stub.proxy对象.

  1.  public static com.example.mysevicejava.IStudentService asInterface(android.os.IBinder obj) {
  2.             if ((obj == null)) {
  3.                 return null;
  4.             }
  5. // queryLocalInterface是Binder的方法，搜索本地是否有可用的对象
  6. // DESCRIPTOR = "com.example.mysevicejava.IStudentService";
  7.             android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
  8.  
  9.              //如果有，则强制类型转换并返回
  10.             if (((iin != null) && (iin instanceof com.example.mysevicejava.IStudentService))) {
  11.                 return ((com.example.mysevicejava.IStudentService) iin);
  12.             }
  13. // //如果没有，则构造一个IStudentService.Stub.Proxy对象
  14.             return new com.example.mysevicejava.IStudentService.Stub.Proxy(obj);
  15.         }

2.4   Stub的静态内部类Proxy

通过上面的new com.example.mysevicejava.IStudentService.Stub.Proxy(obj)调用过来的

  1. private static class Proxy implements com.example.mysevicejava.IStudentService{
  2.  
  3.       private android.os.IBinder mRemote;
  4.       
  5.       //构造方法
  6.       Proxy(android.os.IBinder remote){
  7.         mRemote = remote;
  8.       }
  9.  
  10.       @Override public android.os.IBinder asBinder(){
  11.         return mRemote;
  12.       }
  13.  
  14.       public java.lang.String getInterfaceDescriptor(){
  15.         return DESCRIPTOR;
  16.       }
  17.       .......
  18.       .......
  19. }

通过代码,我们知道

1. Proxy 实现了 com.example.mysevicejava.IStudentService 里面的3个方法

2. Proxy的asBinder()方法返回的mRemote,  mRemote是在Proxy(android.os.IBinder remote) 这个构造方法中赋值的.  

3.  网上有另外的一种结论:

asInterface方法的主要作用：如果是多进程操作，参数obj是BinderProxy对象，就new一个proxy接口；通过调用new com.example.mysevicejava.IStudentService.Stub.Proxy(obj) 就可以知道

把BinderProxy对象保存到mRemote变量，mRemote在aidl中是一个辅助变量.

mRemote 就是 BinderProxy对象.

----- 这条结论再后面的文章中验证.先记住就可以了,

三. Stub 和 Proxy 理解

首先从字面上来理解一下: proxy是代理   Stub是存根

AIDL:  Android interface Definition Language

如果你觉的AIDL中的proxy / stub 比较难理解的话,先触类旁通一下, 换个思维理解 

MIDL:微软接口定义语言Microsoft interface Definition Language, 它是定义COM接口的说明性语言。 关于COM (Component Object Model)，中文译为，组件对象模型, 它也是一种进程间通信接口, 具体用法参考: 理解Com(Component Object model)  这篇文章,但不是我们关注的重点, 我们只是借助于它来理解我们的AIDL中的 proxy-stub 模式 , 拿COM的通信模式图看一下:

打个比方，你到自动取款机上去取款

你不会在乎钱具体放在那里，你只想看到足够或更多的钱从出口出来（这就是com的透明性）。你同银行之间的操作完全是取款机代理实现。你的取款请求通过取款机，传到另一头，银行的服务器，他也没有必要知道你在哪儿取钱，他所关心的是你的身份，和你取款多少。当他确认你的权限，就进行相应的操作，返回操作结果给取款机，取款机根据服务器返回结果，从保险柜里取出相应数量的钱给你。你取出卡后，操作完成。取款机不是直接同服务器连接的，他们之间还有一个“存根”，取款机与存根通信，存根又与服务器通信。从某种意义上说存根就是服务器的代理。（参考COM代理与存根）

概念理解: 

  客户端:  自己

  proxy : 取款机 ，可以理解为银行金融系统取款业务的代理

  服务端: 银行金融系统

  Stub:   取款凭证(显示交易时间,交易金额,存钱/取钱),  它作为银行金融系统的实体存根

再回到AIDLFramework层的架构，如下图：


换而言之，Android就是在传统的C/S架构中加入了一层，实现IPC。图中表明，AIDL类似COM的Proxy/Stub架构。不过是现在android自己的序列化类Pacel。

客户端的代码中调用

  1.  @Override
  2.         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
  3.             Log.e("test", " componentName  :" + componentName);
  4.             mIStudentService = IStudentService.Stub.asInterface(iBinder);
  5.         }

我们再回到2.3 asInterface(android.os.IBinder obj) 这个方法中来

asInterface()：客户端在ServiceConnection通过IStudentService.Stub.asInterface(IBinder)，
会根据是同一进行通信， 还是不同进程通信，返回Stub()实体，或者Stub.Proxy()代理对象

从字面意思看，Stub是存根，Proxy是代理，而这个Stub是谁的存根呢？Proxy又是谁的代理呢？


我理解的是 :  

Stub是 服务端Binder实体的存根.

Proxy则是Stub的代理. 

Stub类： 服务实体，Binder的实现类，服务端一般会实例化一个Binder对象，在服务端onBind中绑定， 客户端asInterface获取到Stub。 这个类在编译aidl文件后自动生成，它继承自Binder，表示它是一个Binder本地对象； 它是一个抽象类，实现了IInterface接口，表明它的子类需要实现Server将要提供的具体能力（即aidl文件中声明的方 法）

Stub.Proxy类： 服务的代理，客户端asInterface获取到Stub.Proxy。 它实现了IInterface接口，说明它是 Binder通信过程的一部分；它实现了aidl中声明的方法，但最终还是交由其中的mRemote成员来处理，说明它是一 个代理对象，mRemote成员实际上就是BinderProxy。供客户端来调用.
通信图:

四. 手写AIDL

我们先来看一下代码目录结构： 

分为4个部分：客户端， 服务端 ， 手写AIDL文件， javabean类
 

直接上代码：

1. 客户端ClientActivity.java

  1. /**
  2.  * @ProjectName: WriteAIDLTest
  3.  * @PackageName: com.example.writeaidltest
  4.  * @Description: java类作用描述
  5.  * @Author: 作者名
  6.  * @CreateDate: 23-3-13 下午1:55
  7.  * @Version: 1.0
  8.  */
  9. public class ClientActivity extends Activity {
  10.  
  11.     private Intent intent;
  12.  
  13.     private IStudent mIStudent;
  14.  
  15.     //是否绑定成功
  16.     boolean mBound = false;
  17.  
  18.  
  19.     @Override
  20.     protected void onCreate(@Nullable Bundle savedInstanceState) {
  21.         super.onCreate(savedInstanceState);
  22.         setContentView(R.layout.activity_main);
  23.  
  24.         intent = new Intent(this, MyServer.class);
  25.  
  26.         Button btn = (Button)findViewById(R.id.button);
  27.         btn.setOnClickListener(new View.OnClickListener() {
  28.             @Override
  29.             public void onClick(View view) {
  30.                 if(mBound) {
  31.                     try {
  32.                         Log.e("test", "mIStudent.getString() 当前线程 :" +   Thread.currentThread().getName());
  33.                         String text = mIStudent.getString();
  34.                         Log.e("test", "mIStudent.getString() after ");
  35.                         Toast.makeText(ClientActivity.this, "内容: " + text, Toast.LENGTH_SHORT).show();
  36.                     } catch (RemoteException e) {
  37.                         e.printStackTrace();
  38.                     }
  39.                 }
  40.             }
  41.         });
  42.  
  43.  
  44.         Button btn1 = (Button)findViewById(R.id.button1);
  45.         btn1.setOnClickListener(new View.OnClickListener() {
  46.             @Override
  47.             public void onClick(View view) {
  48.                 if(mBound) {
  49.                     try {
  50.                         mIStudent.addStudent(new Student(3, "王五"));
  51.                     } catch (RemoteException e) {
  52.                         e.printStackTrace();
  53.                     }
  54.                 }
  55.             }
  56.         });
  57.  
  58.         Button btn2 = (Button)findViewById(R.id.button2);
  59.         btn2.setOnClickListener(new View.OnClickListener() {
  60.             @Override
  61.             public void onClick(View view) {
  62.                 if(mBound) {
  63.                     try {
  64.                         Log.e("test", "获取服务端所有学生的信息:   "+mIStudent.getStudentList());
  65.                     } catch (RemoteException e) {
  66.                         e.printStackTrace();
  67.                     }
  68.                 }
  69.             }
  70.         });
  71.  
  72.     }
  73.  
  74.  
  75.  
  76.     private ServiceConnection connection = new ServiceConnection() {
  77.         @Override
  78.         public void onServiceConnected(ComponentName componentName, IBinder service) {
  79.             Log.e("test", "===客户端===onServiceConnected=====service是一个什么对象: ="+service.getClass().getCanonicalName());
  80.             mBound = true;
  81.             mIStudent = Stub.asInterface(service);
  82.             Log.e("test", "===客户端 mIStudent是一个什么对象:" + mIStudent.getClass().getCanonicalName());
  83.         }
  84.  
  85.         @Override
  86.         public void onServiceDisconnected(ComponentName componentName) {
  87.             Log.e("test", "====onServiceDisconnected=====");
  88.             mBound = false;
  89.         }
  90.     };
  91.  
  92.     //在onstart方法中 调用 bindservice 绑定服务
  93.     @Override
  94.     protected void onStart() {
  95.         super.onStart();
  96.         bindService(intent, connection, Context.BIND_AUTO_CREATE);
  97.     }
  98.  
  99.     //在onstop方法中, 调用unbindservice 解绑服务
  100.     @Override
  101.     protected void onStop() {
  102.         super.onStop();
  103.         unbindService(connection);
  104.         mBound = false;
  105.     }
  106.  
  107.     @Override
  108.     protected void onDestroy() {
  109.         super.onDestroy();
  110.     }
  111. }

2.  服务端代码MyServer.java

  1. /**
  2.  * @ProjectName: WriteAIDLTest
  3.  * @PackageName: com.example.writeaidltest.service
  4.  * @Description: java类作用描述
  5.  * @Author: 作者名
  6.  * @CreateDate: 23-3-13 下午3:12
  7.  * @Version: 1.0
  8.  */
  9. public class MyServer extends Service {
  10.  
  11.     private List<Student> mStudentList = new ArrayList<>();
  12.  
  13.     @Override
  14.     public void onCreate() {
  15.         super.onCreate();
  16.         mStudentList.add(new Student(1, "张三"));
  17.         mStudentList.add(new Student(2, "李四"));
  18.     }
  19.  
  20.     @Nullable
  21.     @Override
  22.     public IBinder onBind(Intent intent) {
  23.         Log.e("test", "==服务端==onBind===new MyBinder()是一个什么对象====="+new MyBinder().getClass().getCanonicalName());
  24.         //return new MyBinder();
  25.         Log.e("test", "==服务端==onBind==myBinder是一个什么对象====="+myBinder.toString());
  26.         return myBinder;
  27.     }
  28.  
  29.     IBinder myBinder = new Stub() {
  30.         @Override
  31.         public String getString() throws RemoteException {
  32.             return "服务端数据  777";
  33.         }
  34.  
  35.         @Override
  36.         public void addStudent(Student student) throws RemoteException {
  37.             mStudentList.add(student);
  38.         }
  39.  
  40.         @Override
  41.         public List<Student> getStudentList() throws RemoteException {
  42.             return mStudentList;
  43.         }
  44.     };
  45.  
  46.     class MyBinder extends Stub{
  47.         @Override
  48.         public String getString() throws RemoteException {
  49.             return "服务端数据  111";
  50.         }
  51.  
  52.         @Override
  53.         public void addStudent(Student student) throws RemoteException {
  54.             mStudentList.add(student);
  55.         }
  56.  
  57.         @Override
  58.         public List<Student> getStudentList() throws RemoteException {
  59.             return mStudentList;
  60.         }
  61.     }
  62.  
  63.     @Override
  64.     public void onDestroy() {
  65.         Log.e("test", "==服务端=onDestroy=====");
  66.         super.onDestroy();
  67.     }
  68.  
  69.  
  70.  
  71. }

3.  序列化 Student.java

  1. public class Student implements Parcelable {
  2.  
  3.     private int id;
  4.     private String name;
  5.  
  6.     public Student(int id, String name) {
  7.         this.id = id;
  8.         this.name = name;
  9.     }
  10.  
  11.     @Override
  12.     public int describeContents() {
  13.         return 0;
  14.     }
  15.  
  16.     @Override
  17.     public void writeToParcel(Parcel dest, int flags) {
  18.         dest.writeInt(id);
  19.         dest.writeString(name);
  20.     }
  21.  
  22.     public void readFromParcel(Parcel parcel) {
  23.         this.id = parcel.readInt();
  24.         this.name = parcel.readString();
  25.     }
  26.  
  27.     public static Parcelable.Creator<Student> CREATOR = new Parcelable.Creator<Student>() {
  28.         @Override
  29.         public Student createFromParcel(Parcel source) {
  30.             return new Student(source);
  31.         }
  32.  
  33.         @Override
  34.         public Student[] newArray(int size) {
  35.             return new Student[0];
  36.         }
  37.     };
  38.  
  39.     private Student(Parcel in) {
  40.         this.id = in.readInt();
  41.         this.name = in.readString();
  42.     }
  43.  
  44.     @Override
  45.     public String toString() {
  46.         return "Student{" +
  47.                 "id=" + id +
  48.                 ", name='" + name + '\'' +
  49.                 '}';
  50.     }
  51. }

4. 最重要，手动仿写AIDL文件  IStudent.java 

相当于 IStudent.aidl 文件用安卓自带工具生成  IStudent.java 

  1. /**
  2.  * @ProjectName: WriteAIDLTest
  3.  * @PackageName: com.example.writeaidltest.aidlfile
  4.  * @Description: 手动仿写AIDL文件
  5.  * @Author: 作者名
  6.  * @CreateDate: 23-3-13 下午1:58
  7.  * @Version: 1.0
  8.  */
  9.  
  10. public interface IStudent extends android.os.IInterface {
  11.     //定义一个DESCRIPTOR
  12.     //意图: 为了一个Binder和一个特定服务接口绑定，以对外提供功能，需要给Binder定义一个DESCRIPTOR描述，表示我这个Binder是提供特定功能链接的，不是随便可以用的
  13.     public static final java.lang.String DESCRIPTOR = "com.example.writeaidltest.aidlfile.IStudentService";
  14.  
  15.  
  16.     //定义操作数据的方法
  17.     //1. 从服务端获取一个简单的字符串
  18.     String getString() throws RemoteException;
  19.  
  20.     //2. 客户端往服务端 添加student对象
  21.     void addStudent(Student student) throws RemoteException;
  22.  
  23.     //3. 客户端从服务段获取 所有Student的信息
  24.     List<Student> getStudentList() throws RemoteException;
  25.  
  26.  
  27.  
  28.  
  29.     //定义方法的id号
  30.     static final int TRANSACTION_getString = IBinder.FIRST_CALL_TRANSACTION + 0;
  31.     static final int TRANSACTION_addStudent = IBinder.FIRST_CALL_TRANSACTION + 1;
  32.     static final int TRANSACTION_getStudentList = IBinder.FIRST_CALL_TRANSACTION + 2;
  33. }

手动仿写AIDL文件   Stub.java

抽象类 Stub

  1. public abstract class Stub extends android.os.Binder implements IStudent{
  2.  
  3.     //构造方法
  4.     public Stub() {
  5.         this.attachInterface(this, DESCRIPTOR);
  6.     }
  7.  
  8.     public static IStudent asInterface(IBinder obj) {
  9.  
  10.         if (obj == null) {
  11.             return null;
  12.         }
  13.  
  14.         IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
  15.         if (iin != null && (iin instanceof IStudent)) {
  16.             return (IStudent)iin;
  17.         }
  18.  
  19.         // 传入binder对象，返回一个服务代理对象
  20.         return new Proxy(obj);
  21.  
  22.     }
  23.  
  24.     @SuppressLint("NewApi")
  25.     @Override
  26.     protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
  27.         switch (code) {
  28.             case INTERFACE_TRANSACTION:
  29.                 reply.writeString(DESCRIPTOR);
  30.                 return true;
  31.  
  32.             case TRANSACTION_getString:
  33.                 // 获取IBinder接口标志
  34.                 data.enforceInterface(DESCRIPTOR);
  35.                 //这个是服务端自己实现getString方法,获取返回值
  36.                 String stringResult = this.getString();
  37.                 Log.e("test", " stub onTransact 当前线程: "+Thread.currentThread().getName());
  38.                 reply.writeNoException();
  39.                 reply.writeString(stringResult);
  40.                 return true;
  41.  
  42.             case TRANSACTION_addStudent:
  43.                 // 获取IBinder接口标志
  44.                 data.enforceInterface(DESCRIPTOR);
  45.                 // 获取传入的Student对象
  46.                 Student arg0 = null;
  47.                 if (data.readInt() != 0) {
  48.                     arg0 = Student.CREATOR.createFromParcel(data);
  49.                 }
  50.                 this.addStudent(arg0);
  51.                 reply.writeNoException();
  52.                 return true;
  53.  
  54.             case TRANSACTION_getStudentList:
  55.                 data.enforceInterface(DESCRIPTOR);
  56.                 //
  57.                 List<Student> studentList = null;
  58.                 studentList = this.getStudentList();
  59.                 reply.writeNoException();
  60.                 reply.writeTypedList(studentList);
  61.                 return true;
  62.         }
  63.         return super.onTransact(code, data, reply, flags);
  64.     }
  65.  
  66.     @Override
  67.     public IBinder asBinder() {
  68.         return this;
  69.     }
  70. }

手动仿写  Proxy.java 

  1. public class Proxy implements IStudent{
  2.  
  3.     private IBinder mRemote;
  4.  
  5.     public Proxy(IBinder remote) {
  6.         mRemote = remote;
  7.         Log.e("test", "===Proxy中 mRemote 是一个什么对象: " + mRemote.getClass().getCanonicalName());
  8.     }
  9.  
  10.  
  11.  
  12.     @Override
  13.     public String getString() throws RemoteException {
  14.  
  15.         Parcel data = Parcel.obtain(); // 跨进程传输数据对象
  16.         Parcel reply = Parcel.obtain(); // 跨进程传输返回结果
  17.         java.lang.String _result;
  18.         try {
  19.             data.writeInterfaceToken(DESCRIPTOR);
  20.             // 调Stub的onTransact方法进行Stub.TRANSACTION_getString，远端返回
  21.             Log.e("test", "mRemote transact 当前线程 :" +   Thread.currentThread().getName());
  22.             mRemote.transact(TRANSACTION_getString, data, reply, 0);
  23.  
  24.             reply.readException();
  25.             _result = reply.readString();
  26.  
  27.         }finally {
  28.             data.recycle();
  29.             reply.recycle();
  30.         }
  31.         return _result;
  32.     }
  33.  
  34.     @Override
  35.     public void addStudent(Student student) throws RemoteException {
  36.         Parcel data = Parcel.obtain(); // 跨进程传输数据对象
  37.         Parcel reply = Parcel.obtain(); // 跨进程传输返回结果
  38.         try{
  39.             // 写入IBinder接口标志，一般为全类名，用户数据校验
  40.             data.writeInterfaceToken(DESCRIPTOR);
  41.             if (student != null){
  42.                 //写入数据
  43.                 data.writeInt(1);
  44.                 student.writeToParcel(data, 0);
  45.             } else {
  46.                 data.writeInt(0);
  47.             }
  48.             // 调Stub的onTransact方法进行Stub.TRANSACTION_addBook处理，远端返回
  49.             mRemote.transact(Stub.TRANSACTION_addStudent, data, reply, 0);
  50.             reply.readException();
  51.         } finally {
  52.             data.recycle();
  53.             reply.recycle();
  54.         }
  55.     }
  56.  
  57.     @Override
  58.     public List<Student> getStudentList() throws RemoteException {
  59.         Parcel data = Parcel.obtain(); // 跨进程传输数据对象
  60.         Parcel reply = Parcel.obtain(); // 跨进程传输返回结果
  61.  
  62.         List<Student> result;
  63.         try {
  64.             // 写入IBinder接口标志，一般为全类名，用户数据校验
  65.             data.writeInterfaceToken(DESCRIPTOR);
  66.             // 调Stub的onTransact方法进行Stub.TRANSACTION_getStudentList，远端返回
  67.             mRemote.transact(TRANSACTION_getStudentList, data, reply, 0);
  68.             reply.readException();
  69.             result = reply.createTypedArrayList(Student.CREATOR);
  70.         } finally {
  71.             reply.recycle();
  72.             data.recycle();
  73.         }
  74.  
  75.         return result;
  76.     }
  77.  
  78.  
  79.     // 返回Stub类传入的Binder对象
  80.     @Override
  81.     public IBinder asBinder() {
  82.         return mRemote;
  83.     }
  84.  
  85.     public java.lang.String getInterfaceDescriptor() {
  86.         return DESCRIPTOR;
  87.     }
  88. }

清单AndroidManifest.xml 文件
 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.example.writeaidltest">
  4.  
  5.     <application
  6.         android:allowBackup="true"
  7.         android:icon="@mipmap/ic_launcher"
  8.         android:label="@string/app_name"
  9.         android:roundIcon="@mipmap/ic_launcher_round"
  10.         android:supportsRtl="true"
  11.         android:theme="@style/Theme.WriteAIDLTest">
  12.         <activity android:name=".client.ClientActivity">
  13.             <intent-filter>
  14.                 <action android:name="android.intent.action.MAIN" />
  15.  
  16.                 <category android:name="android.intent.category.LAUNCHER" />
  17.             </intent-filter>
  18.         </activity>
  19.  
  20.         <！-- service 运行在另外一个进程中 -->
  21.         <service
  22.             android:name=".service.MyServer"
  23.             android:exported="true"
  24.             android:enabled="true"
  25.             android:process=":remote">
  26.             <intent-filter>
  27.                 <action android:name="com.my.binder" />
  28.                 <category android:name="android.intent.category.DEFAULT" />
  29.             </intent-filter>
  30.         </service>
  31.     </application>
  32.

上面的例子是模拟进程间通信的整个过程，可以通过log看出客户端发送数据给服务端，然后服务端处理之后再返回给客户端的整个流程。

大家可以通过这个Demo去学习AIDL的原理，供参考！

Demo 已上传： https://download.csdn.net/download/u012514113/87906468

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/122796
推荐阅读
相关标签

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

  

闽ICP备14008679号