AIDL 自动生成java代码——从分析内部类Stub、Proxy入手

最新推荐文章于 2024-03-28 11:58:30 发布
最新推荐文章于 2024-03-28 11:58:30 发布
阅读量2.7k 收藏 11
点赞数 3
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlian523/article/details/98469806
版权

前言

使用AIDL接口可以使得我们在调用其他进程的对象的方法，像调用自己进程本地对象的方法一样简单。本文将从AIDL接口文件自动生成的java文件来分析调用过程，虽然分析可能不够底层，但一定能对理解AIDL起到帮助。

代码

AIDL文件如下（IListener的接口文件不重要，这里它是个空接口都可以）

package com.java.prac;
import com.java.prac.IListener;

interface IService {

    void registerListener(in IListener listener);

    void unregisterListener(in IListener listener);

    byte SerTestIn(in byte[] pa);

    byte SerTestOut(out byte[] pa);
    
    byte SerTestInout(inout byte[] pa);
}

对应自动生成的java文件放在后面了。

分析

首先对自动生成的java文件进行分析。不关注其内部类，单看IService接口的声明方法，它已经声明好了aidl文件里的5个方法。需要注意的是IService接口继承了IInterface接口。

IService interface

public interface IService extends android.os.IInterface
{
	//忽略内部类
    public void registerListener(com.java.prac.IListener listener) throws android.os.RemoteException;
    public void unregisterListener(com.java.prac.IListener listener) throws android.os.RemoteException;
    public byte SerTestIn(byte[] pa) throws android.os.RemoteException;
    public byte SerTestOut(byte[] pa) throws android.os.RemoteException;
    public byte SerTestInout(byte[] pa) throws android.os.RemoteException;
}

而IInterface接口的定义如下，IService接口并没有去实现asBinder方法，这说明实现asBinder的任务交给实现IService接口的派生类。这也暗示了asBinder方法在不同的派生类下有着不同的实现。

package android.os;
public interface IInterface
{
	public abstract android.os.IBinder asBinder();
}

其次，IService接口发现有两个内部类，一个是IService$Stub，一个是IService$Stub$Proxy，两个内部类都implement了IService接口。但很明显，一个是用来在service所处的进程中继承并实现AIDL接口的（这个才是真正的方法实现），另一个是用来作为cilent来访问调用远程进程的service的方法的。

IService$Stub内部类

    /** Local-side IPC implementation stub class. */
    public static abstract class Stub extends android.os.Binder implements com.java.prac.IService
    {
        private static final java.lang.String DESCRIPTOR = "com.java.prac.IService";
        /** Construct the stub at attach it to the interface. */
        public Stub()
        {
            this.attachInterface(this, DESCRIPTOR);
        }
        /**
         * Cast an IBinder object into an com.java.prac.IService interface,
         * generating a proxy if needed.
         */
        public static com.java.prac.IService asInterface(android.os.IBinder obj)
        {
            if ((obj==null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin!=null)&&(iin instanceof com.java.prac.IService))) {
                return ((com.java.prac.IService)iin);
            }
            return new com.java.prac.IService.Stub.Proxy(obj);
        }
        @Override public android.os.IBinder asBinder()
        {
            return this;
        }
        @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
        {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code)
            {	//省略
                case TRANSACTION_SerTestIn:
                {
                    data.enforceInterface(descriptor);
                    byte[] _arg0;
                    _arg0 = data.createByteArray();
                    byte _result = this.SerTestIn(_arg0);
                    reply.writeNoException();
                    reply.writeByte(_result);
                    return true;
                }
                //省略
			}
        }
        static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_unregisterListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
        static final int TRANSACTION_SerTestIn = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
        static final int TRANSACTION_SerTestOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
        static final int TRANSACTION_SerTestInout = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4);
    }
  • stub类是一个抽象类，需要派生类才能生成对象。
  • 这个类同时继承Binder并实现了IService方法，意味着这个类可以在Binder和IService之间强制转换类型。
  • 从onTransact方法中可以看到，switch case的逻辑里是根据stub定义的常量来进入的，但是却没有找到谁调用了这个方法。
  • switch case的逻辑里，调用方法最终调用的是byte _result = this.SerTestIn(_arg0)，这说明IService$Stub是用来在service所处的进程中继承并实现AIDL接口的。因为方法的真正实现在自己的派生类对象里，所以会调用this的方法。
  • asBinder方法里返回this，因为自己的派生类对象将会是真正的service实现，所以就可以理直气壮地返回自己了。
  • asInterface是一个static方法，是一个工具方法。这个方法根据IBinder参数来作判断。当返回return ((com.java.prac.IService)iin)时，说明IBinder参数是stub的派生类对象，Binder里对应的源码如下：
    //frameworks/base/core/java/android/os/Binder.java
	//这个函数属于Binder类
    public @Nullable IInterface queryLocalInterface(@NonNull String descriptor) {
        if (mDescriptor != null && mDescriptor.equals(descriptor)) {
            return mOwner;
        }
        return null;
    }

但mOwner的定义为private IInterface mOwner;，它通过this.attachInterface(this, DESCRIPTOR);来赋值给mOwner。

    //frameworks/base/core/java/android/os/Binder.java
	//这个函数属于Binder类
    public void attachInterface(@Nullable IInterface owner, @Nullable String descriptor) {
        mOwner = owner;
        mDescriptor = descriptor;
    }

这样，一个stub派生类对象几经转手，最后以IService引用而存在着。这样做的好处是只会暴露IService的方法给外部。

而当返回return new com.java.prac.IService.Stub.Proxy(obj);时，说明iin==null了，一般是这种情况。这说明传进来的IBinder参数其对应的类也实现了queryLocalInterface方法，但是却返回的是null。对应的源码如下（所以这种情况下的obj的实际类型为BinderProxy）：

    //frameworks/base/core/java/android/os/Binder.java
	//这个函数属于BinderProxy类
    public IInterface queryLocalInterface(String descriptor) {
        return null;
    }
  • 总结一下就是，当调用方和service实现方处于同一个进程时，会返回return ((com.java.prac.IService)iin);；当调用方和service实现方处于不同进程时，会返回return new com.java.prac.IService.Stub.Proxy(obj);。当然，这是因为asInterface方法传入参数的实际类型的不同导致的。

IService$Stub$Proxy内部类

        private static class Proxy implements com.java.prac.IService
        {
            private android.os.IBinder mRemote;
            Proxy(android.os.IBinder remote)
            {
                mRemote = remote;
            }
            @Override public android.os.IBinder asBinder()
            {
                return mRemote;
            }
            public java.lang.String getInterfaceDescriptor()
            {
                return DESCRIPTOR;
            }
			//省略
            @Override public byte SerTestIn(byte[] pa) throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                byte _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeByteArray(pa);
                    mRemote.transact(Stub.TRANSACTION_SerTestIn, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readByte();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
		//省略
        }
  • proxy已经不是抽象类了，可以不需要派生类，就直接生成对象了。
  • 很明显，proxy的构造函数在stub里面的return new com.java.prac.IService.Stub.Proxy(obj);被调用到了。
  • 由于proxy对象是在远程调用方使用的，所以asBinder方法就应该返回这个IBinder类型的mRemote成员（实际类型为BinderProxy）。
  • 从switch case的逻辑看，调用mRemote.transact方法时的第一个参数，刚好可以被stub的switch逻辑用来处理各种case。transact的各个实参刚好和onTransact的形参对应上了。
  • mRemote.transact方法会调用到transactNative(code, data, reply, flags);即用JNI调用c++代码去，之后会通过系统调用进入内核空间（即用户态转到内核态），最后将服务实现方的线程唤醒，并调用相应函数。

系统图

在这里插入图片描述
从系统图中可以看出Android中设计模式的优良应用，IInterface接口中定义了一个方法asBinder可以返回IBinder类型，而IBinder接口中定义了一个queryLocalInterface方法可以返回IInterface类型。这两个方法刚好相反，使得IBinder类型和IInterface类型可以相互转换。

而为了可以相互转换，它们的派生类：Stub同时继承了IService和Binder；Proxy虽然只继承了IService，但拥有一个BinderProxy的成员。

自动生成的java代码

package com.java.prac;
public interface IService extends android.os.IInterface
{
    /** Local-side IPC implementation stub class. */
    public static abstract class Stub extends android.os.Binder implements com.java.prac.IService
    {
        private static final java.lang.String DESCRIPTOR = "com.java.prac.IService";
        /** Construct the stub at attach it to the interface. */
        public Stub()
        {
            this.attachInterface(this, DESCRIPTOR);
        }
        /**
         * Cast an IBinder object into an com.java.prac.IService interface,
         * generating a proxy if needed.
         */
        public static com.java.prac.IService asInterface(android.os.IBinder obj)
        {
            if ((obj==null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin!=null)&&(iin instanceof com.java.prac.IService))) {
                return ((com.java.prac.IService)iin);
            }
            return new com.java.prac.IService.Stub.Proxy(obj);
        }
        @Override public android.os.IBinder asBinder()
        {
            return this;
        }
        @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
        {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code)
            {
                case INTERFACE_TRANSACTION:
                {
                    reply.writeString(descriptor);
                    return true;
                }
                case TRANSACTION_registerListener:
                {
                    data.enforceInterface(descriptor);
                    com.java.prac.IListener _arg0;
                    _arg0 = com.java.prac.IListener.Stub.asInterface(data.readStrongBinder());
                    this.registerListener(_arg0);
                    reply.writeNoException();
                    return true;
                }
                case TRANSACTION_unregisterListener:
                {
                    data.enforceInterface(descriptor);
                    com.java.prac.IListener _arg0;
                    _arg0 = com.java.prac.IListener.Stub.asInterface(data.readStrongBinder());
                    this.unregisterListener(_arg0);
                    reply.writeNoException();
                    return true;
                }
                case TRANSACTION_SerTestIn:
                {
                    data.enforceInterface(descriptor);
                    byte[] _arg0;
                    _arg0 = data.createByteArray();
                    byte _result = this.SerTestIn(_arg0);
                    reply.writeNoException();
                    reply.writeByte(_result);
                    return true;
                }
                case TRANSACTION_SerTestOut:
                {
                    data.enforceInterface(descriptor);
                    byte[] _arg0;
                    int _arg0_length = data.readInt();
                    if ((_arg0_length<0)) {
                        _arg0 = null;
                    }
                    else {
                        _arg0 = new byte[_arg0_length];
                    }
                    byte _result = this.SerTestOut(_arg0);
                    reply.writeNoException();
                    reply.writeByte(_result);
                    reply.writeByteArray(_arg0);
                    return true;
                }
                case TRANSACTION_SerTestInout:
                {
                    data.enforceInterface(descriptor);
                    byte[] _arg0;
                    _arg0 = data.createByteArray();
                    byte _result = this.SerTestInout(_arg0);
                    reply.writeNoException();
                    reply.writeByte(_result);
                    reply.writeByteArray(_arg0);
                    return true;
                }
                default:
                {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }
        private static class Proxy implements com.java.prac.IService
        {
            private android.os.IBinder mRemote;
            Proxy(android.os.IBinder remote)
            {
                mRemote = remote;
            }
            @Override public android.os.IBinder asBinder()
            {
                return mRemote;
            }
            public java.lang.String getInterfaceDescriptor()
            {
                return DESCRIPTOR;
            }

            @Override public void registerListener(com.java.prac.IListener listener) throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null)));
                    mRemote.transact(Stub.TRANSACTION_registerListener, _data, _reply, 0);
                    _reply.readException();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }

            @Override public void unregisterListener(com.java.prac.IListener listener) throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeStrongBinder((((listener!=null))?(listener.asBinder()):(null)));
                    mRemote.transact(Stub.TRANSACTION_unregisterListener, _data, _reply, 0);
                    _reply.readException();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }

            @Override public byte SerTestIn(byte[] pa) throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                byte _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeByteArray(pa);
                    mRemote.transact(Stub.TRANSACTION_SerTestIn, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readByte();
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
            @Override public byte SerTestOut(byte[] pa) throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                byte _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((pa==null)) {
                        _data.writeInt(-1);
                    }
                    else {
                        _data.writeInt(pa.length);
                    }
                    mRemote.transact(Stub.TRANSACTION_SerTestOut, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readByte();
                    _reply.readByteArray(pa);
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
            @Override public byte SerTestInout(byte[] pa) throws android.os.RemoteException
            {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                byte _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeByteArray(pa);
                    mRemote.transact(Stub.TRANSACTION_SerTestInout, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readByte();
                    _reply.readByteArray(pa);
                }
                finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }
        static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_unregisterListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
        static final int TRANSACTION_SerTestIn = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
        static final int TRANSACTION_SerTestOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
        static final int TRANSACTION_SerTestInout = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4);
    }
    public void registerListener(com.java.prac.IListener listener) throws android.os.RemoteException;
    public void unregisterListener(com.java.prac.IListener listener) throws android.os.RemoteException;
    public byte SerTestIn(byte[] pa) throws android.os.RemoteException;
    public byte SerTestOut(byte[] pa) throws android.os.RemoteException;
    public byte SerTestInout(byte[] pa) throws android.os.RemoteException;
}
anlian523
关注
专栏目录
Android之Binder的使用及上层原理，Aidl自动生成binder
qq_36523667的博客
01-27 452
借鉴自开发艺术 Binder是Android中的一个类，实现了IBinder接口 IPC角度，是一种跨进程通信方式 可以理解为一种虚拟的物理设备，它的设备驱动是/dev/binder，Linux中没有这种通信方式 Framework层，Binder是ServiceManager连接各种Manager（ActivityManager、WindowManager等）和相应Manager
理解 Android Binder 机制（四）：补充篇-AIDL以及Proxy-Stub设计模式
做有意思的事情
02-07 1623
在 理解Android Binder机制(三)：Java篇时最后面说到了AIDL，本篇将会详细介绍。 前言： IBinder是Android框架的通用性接口，通用性接口意味着，众人可以共享的接口。由于通用性(或共享性)，框架开发者可以藉单一的通用性接口来<包容>形形色色的特殊性接口；具有标准化接口的<减法设计>效果，但又不会减损特性用户或App对特殊性接口的需求。兼顾标准性和特殊性的，是框架通用性接口设计的重要指标；这是任何框架开发里，都必须面对的高度挑战性任务之一。 IBinder
AIDL，在Stub类中的asInterface函数
weixin_38451161的博客
03-22 8946
在使用AIDL通信的时候，在Stub类中都会生成一个asInterface函数，以《Android开发艺术探索》中的例子来分析，其生成的asInterface函数源码为： 1 /** 2 * Cast an IBinder object into an com.willhua.demoaidl.aidl.IBookManager 3 ...
Android Studio编写AIDL文件后如何实现自动编译生成
08-19
主要介绍了Android Studio编写AIDL文件后如何实现自动编译生成，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
说说AIDL生成的Java代码
z979451341的博客
03-23 3947
首先的说明，本篇博客是从AIDL生产java代码这方面入手说明的，而且使用的是上一篇博客的项目做示范项目，所以我在本篇博客我只会贴出部分关键代码，其他代码请看上一篇博客。 https://blog.csdn.net/z979451341/article/details/64905709 我在com.example.aidlserver路径创建一个AIDL文件 interface IRem...
Android跨进程通信的AIDL生成的文件代码解析，asInterface，Stub，Proxy
weixin_46039528的博客
10-10 936
主要是客户端调用，把远程的IBinder实现类对象转换成客户端本地的一个接口引用，这样在客户端就能调用服务端定义好的方法。stub是抽象类，意味着我们定义在aidl里面的接口都需要实现，生成的文件源码中并没有去实现我们定义的接口方法。在onTransact中，匹配上了TRANSACTION_request这个code就可以执行对应的远程方法。做一些判断，有的话就直接返回这个Ibinder对象，没有的话就new一个新的。调用远程的方法实际上是调用下面的这个Proxy中的方法。匹配我们对应的要调用的方法。
AIDL与stub
04-22 217
Stub翻译成中文是存根的意思，注意Stub对象是在被调用端进程，也就是服务端进程,至此，服务端aidl服务端得编码完成了。 stub是为了方便client，service交互而生成出来的代码。AIDL(android 接口描述语言)是一个IDL语言，它可以生成一段代码，可以使在一个android设备上运行的两个进程使用内部通信进程进行交互。如果你需要在一个进程中(例如:...
aidl文件生成Java、C++[android]、C++[ndk]、Rust接口
最新发布
似霰的博客
03-28 1443
aidl文件生成Java、C++[android]、C++[ndk]、Rust接口
AIDL与Proxy--stub设计模式
TouchOfSun的博客
03-25 655
Aidl与Proxy--stub设计模式（学习笔记一）
android stub 在哪定义,从android aidl理解Proxy/stub模式
weixin_30894765的博客
05-27 746
在小7写的上一篇文章《android IPC通信机制梳理》里，我讲到了如果activity要想和一个跨进程的Service进行通信就需要通过Binder框架，获取到IBinder对象，并调用transact()方法来达到通信的目的。该方法里的第一个参数是整数型的code，表示的是请求的服务类型，比如说我想请求使用某播放器服务，我就需要制定一个规则：当code为1时表示开始播放，当code为2时表示...
JAVa调用aidl_aidl demo调用原理
weixin_34923852的博客
02-25 252
通过网络的例子，生成的BookManager如下所示：service和client都是相同的java文件生成的。这个类的例子添加book和查询book两个例子客户端创建bookmananger方法：bookManager = BookManager.Stub.asInterface(iBinder);客户端里的iBinder,是binderProxy类的创建一个proxy的例子点击添加后点击后调用...
Android AIDL的使用（配源码）
【全部原创，全部干货】【Android、车载MCU、AIGC】
06-06 841
Android 跨进程 通信 IPC AIDL使用 Demo 手把手
AIDL中的Proxy,Stub以及其关系
helloworld
06-16 1461
在上篇文章中，了解了ITest.java与Proxy,Stub三者的层次关系。 public interface ITest extends android.os.IInterface { //Stub是一个Binder，也是一个ITest public static abstract class Stub extends android.os.Binder implements com.ex...
android aidl继承stub,Android应用开发Android 中AIDL的使用与理解
weixin_39713814的博客
05-30 663
本文将带你了解Android应用开发Android 中AIDL的使用与理解，希望本文对大家学Android有所帮助。AIDL的使用：最常见的aidl的使用就是Service的跨进程通信了，那么我们就写一个Activity和Service的跨进程通信吧。首先，我们就在AS里面新建一个aidl文件(ps:现在AS建aidl不要求和java包名相同了)：package aidl;interface IM...
【Binder 机制】AIDL 分析 ( 分析 AIDL 文件生成的 Java 源文件 | Binder | IBinder | Stub | Proxy )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
09-16 1007
一、分析 AIDL 文件生成的 Java 源文件、 1、IMyAidlInterface.java 中的类结构、 2、DESCRIPTOR 描述符、 3、Stub 构造方法、 4、Stub.asInterface 方法、 5、Stub.onTransact 方法、 6、Stub.Proxy 代理类、
理解AIDL中的Stub与Stub.Proxy
yzpbright的博客
12-25 2421
参考： 理解Aidl中Stub和Stub.Proxy 存根类(stub) 是什么意思？有什么作用？
AIDL --- Android中的远程接口
01-04 1750
http://www.angryredplanet.com/~hackbod/openbinder/docs/html/BinderProcessModel.html AIDL --- Android中的远程接口     在Android中, 每个应用程序都可以有自己的进程. 在写UI应用的时候, 经常要用到Servi
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值