Android中Binder与AIDL之间的关系

最新推荐文章于 2023-07-16 09:23:00 发布
最新推荐文章于 2023-07-16 09:23:00 发布
阅读量2.9k 收藏 8
点赞数 2
分类专栏： Android Android开发进阶从小工到专家笔记 Android开发艺术探索笔记 面试相关 文章标签： Android开发进阶从小工到专家笔记 Android开发艺术探索笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lj402159806/article/details/85038382
版权

Android中Binder与AIDL之间的关系

Binder

  • Android中特有的一种进程间通信方式,一种虚拟的物理设备,设备驱动是/dev/binder
  • Android中实现了IBinder接口的一个类
  • ServiceManager连接各种Manager（ActivityManager、WindowManager等等）和相应ManagerService的桥梁
  • 应用层客户端和服务端进行通信的媒介

Android开发中，Binder主要用在Service中包括AIDL和Messager，当客户端bindService时服务端会返回一个包含了服务端业务调用的Binder对象，通过这个Binder对象，客户端就可以获取服务端提供的服务或者数据

AIDL

AIDL全称Android接口描述语言，是Android开发工具中提供的一种文件格式，通过在文件中预先定义接口，然后快速生成Binder机制的代码，省去了手动编写Binder机制

AIDL通信流程

使用AIDL来实现进程间通信分为服务端和客户端两个方面：

  • 服务端
    服务端需要创建Service用来监听客户端请求，然后创建AIDL文件声明暴露给客户端的接口，最后在Serive中实现这个AIDL接口
  • 客户端
    客户端需要先绑定Service，绑定成功后将服务端返回的Binder对象转换成AIDL接口所属的类型，然后调用AIDL中的方法

通过AIDL生成Binder机制文件

在客户端新建一个AIDL文件后默认会有一个basicTypes函数（基本示例，演示可以用在AIDL中作为参数和返回值的一些基本类型，这里删除），添加一个login函数

// Test.aidl
package com.gavinandre.aidl;

interface Test {
    void login(String userName, String pwd);
}

rebuild后会在build/generated/source/aidl/debug/${packageName}/目录下生成同名的java文件，下面代码就是系统生成的，只是为了方便查看稍微做了一下格式和顺序调整

package com.gavinandre.aidl;
/**
 * 根据Test.aidl生成的接口
 */
public interface Test extends android.os.IInterface {
    /**
     * 声明login接口
     */
    public void login(java.lang.String userName, java.lang.String pwd) throws android.os.RemoteException;

    /**
     * Stub类继承自Binder,并且实现了test接口
     */
    public static abstract class Stub extends android.os.Binder implements com.gavinandre.aidl.Test {
        private static final java.lang.String DESCRIPTOR = "com.gavinandre.aidl.Test";

        /**
         * 用于标识在transact过程中客户端所请求的到底是哪个方法
         */
        static final int TRANSACTION_login = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);

        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * 将Binder转换为com.gavinandre.aidl.Test接口（同进程），
         * 或者包装为一个Proxy（不同进程）
         */
        public static com.gavinandre.aidl.Test asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.gavinandre.aidl.Test))) {
                return ((com.gavinandre.aidl.Test) iin);
            }
            return new com.gavinandre.aidl.Test.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;
                }

                /**
                 * 执行login函数时提交给Binder的数据
                 */
                case TRANSACTION_login: {
                    data.enforceInterface(descriptor);
                    java.lang.String _arg0;
                    _arg0 = data.readString();
                    java.lang.String _arg1;
                    _arg1 = data.readString();
                    this.login(_arg0, _arg1);
                    reply.writeNoException();
                    return true;
                }
                default: {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }

        /**
         * 不同进程会创建本地代理,通过Binder与服务端的对象进行交互
         */
        private static class Proxy implements com.gavinandre.aidl.Test {
            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;
            }

            /**
             * 实现login接口
             */
            @Override
            public void login(java.lang.String userName, java.lang.String pwd) 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.writeString(userName);
                    _data.writeString(pwd);
                    mRemote.transact(Stub.TRANSACTION_login, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }
    }
}

Binder机制分析

通过AIDL自动生成的这个类看起来逻辑混乱，但是实际上其实很清晰，通过它可以清楚的了解到Binder的工作机制，下面代码我做了一些精简：

package com.gavinandre.aidl;
/**
 * 根据Test.aidl生成的接口
 */
public interface Test extends android.os.IInterface {
    /**
     * 声明login接口
     */
    public void login(java.lang.String userName, java.lang.String pwd) throws android.os.RemoteException;

    /**
     * Stub类继承自Binder,并且实现了test接口
     */
    public static abstract class Stub extends android.os.Binder implements com.gavinandre.aidl.Test {
        
        //省略...

        /**
         * 用于标识在transact过程中客户端所请求的到底是哪个方法
         */
        static final int TRANSACTION_login = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);

        /**
         * 将Binder转换为com.gavinandre.aidl.Test接口（同进程），
         * 或者包装为一个Proxy（不同进程）
         */
        public static com.gavinandre.aidl.Test asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.gavinandre.aidl.Test))) {
                return ((com.gavinandre.aidl.Test) iin);
            }
            return new com.gavinandre.aidl.Test.Stub.Proxy(obj);
        }

        @Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            //省略...
            switch (code) {
                //省略...
                /**
                 * 执行login函数时提交给Binder的数据
                 */
                case TRANSACTION_login: {
                    data.enforceInterface(descriptor);
                    java.lang.String _arg0;
                    _arg0 = data.readString();
                    java.lang.String _arg1;
                    _arg1 = data.readString();
                    this.login(_arg0, _arg1);
                    reply.writeNoException();
                    return true;
                }
                //省略...
            }
        }

        /**
         * 不同进程会创建本地代理,通过Binder与服务端的对象进行交互
         */
        private static class Proxy implements com.gavinandre.aidl.Test {
            private android.os.IBinder mRemote;

            //省略...

            /**
             * 实现login接口
             */
            @Override
            public void login(java.lang.String userName, java.lang.String pwd) 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.writeString(userName);
                    _data.writeString(pwd);
                    mRemote.transact(Stub.TRANSACTION_login, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }
    }
}

首先声明了login方法，显然就是Test.aidl中声明的方法。同时还声明了一个整型id（TRANSACTION_login）来标识这个方法，这个id用于标识在transact过程中客户端所请求的到底是哪个方法。然后可以看到一个内部类Stub继承于Binder并且实现了Test接口，当客户端和服务端都处于同一个进程时，login方法调用不会走跨进程的transact，而当处于不同进程时才会走transact过程，这个逻辑由asInterface方法与内部代理类Proxy来完成

由此可见这个接口的核心就是它的内部类Stub和Stub的内部类Proxy，下面来详细介绍下这两个类内的重要方法：

  • DESCRIPTOR
    Binder的唯一标识，一般用当前Binder的类名表示
    private static final java.lang.String DESCRIPTOR = "com.gavinandre.aidl.Test";
  • asInterface(android.os.IBinder obj)
    用于将服务端的Binder对象转换成客户端所需的AIDL接口类型对象，如果客户端和服务端位于同一进程则返回服务端Stub对象本身，如果不同进程就返回系统封装后的Stub.proxy对象
    /**
 * 将Binder转换为com.gavinandre.aidl.Test接口（同进程），
 * 或者包装为一个Proxy（不同进程）
 */
public static com.gavinandre.aidl.Test asInterface(android.os.IBinder obj) {
    if ((obj == null)) {
        return null;
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (((iin != null) && (iin instanceof com.gavinandre.aidl.Test))) {
        return ((com.gavinandre.aidl.Test) iin);
    }
    return new com.gavinandre.aidl.Test.Stub.Proxy(obj);
}
  • asBinder
    返回当前Binder对象
    @Override
public android.os.IBinder asBinder() {
    return this;
}
  • onTransact
    运行在服务端中的Binder线程池中，当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法来处理。服务端通过Stub中定义的整型id确定请求的目标方法，接着从data中取出目标方法的所需参数（如果有参数），然后执行目标方法。当目标方法执行完毕后向reply中写入返回值（如果有返回值）。
    如果onTransact方法返回false，那么客户端的请求就会失败，因此可以用这个特性来做权限验证
    @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;
        }

        /**
         * 执行login函数时提交给Binder的数据
         */
        case TRANSACTION_login: {
            data.enforceInterface(descriptor);
            java.lang.String _arg0;
            _arg0 = data.readString();
            java.lang.String _arg1;
            _arg1 = data.readString();
            this.login(_arg0, _arg1);
            reply.writeNoException();
            return true;
        }
        default: {
            return super.onTransact(code, data, reply, flags);
        }
    }
}
  • Proxy#login
    客户端发起跨进程请求才会调用此方法，内部实现：首先创建输入型Parcel对象_data、输出型Parcel对象_reply和返回值对象（如果有的话），然后把该方法的参数信息写入_data中（如果有参数），接着调用transace方法来发起RPC（远程过程调用）请求，同时挂起当前线程，然后服务端的onTransact方法会被调用到，直到RPC过程返回后，当前线程继续执行，并从_reply中取出RPC过程的返回结果，最后将数据放入返回值对象中返回数据
    /**
 * 实现login接口
 */
@Override
public void login(java.lang.String userName, java.lang.String pwd) 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.writeString(userName);
        _data.writeString(pwd);
        mRemote.transact(Stub.TRANSACTION_login, _data, _reply, 0);
        _reply.readException();
    } finally {
        _reply.recycle();
        _data.recycle();
    }
}

AIDL支持的数据类型

  • 基本数据类型 int、long、char、boolean、double等，只支持定向tag in
  • String和CharSequence，只支持定向tag in
  • List：其中元素必须是aidl支持的数据类型，接收方得到的总是ArrayList
  • Map：其中元素必须是aidl支持的数据类型，接收方得到的总是HashMap
  • Parcelable：所有实现了Parcelable接口的对象
  • AIDL：所有的AIDL接口本身也可以在AIDL文件中使用

以上6种数据类型就是AIDL所支持的所有类型，其中自定义的Parcelable对象和AIDL对象必须要显式import进来，不管是否在同一个包内，如果是Parcelable对象的话必须新建一个同名的AIDL文件，并在其中声明为Parcel类型。

AIDL中除了基本数据类型，其他类型的参数必须标上方向：in（客户端到服务端）、out（服务端到客户端）或者inout（双向），要根据实际需要指定参数类型，不能一概使用out或者inout，因为这在底层实现是有开销的

AIDL接口中只支持方法，不支持声明静态常量

AIDL接口的管理方式

RemoteCallbackList是系统专门提供用来删除跨进程listener接口的，当客户端进程终止后，它能够自动移除客户端所注册的listener，它内部还自动实现了线程同步功能

RemoteCallbackList是一个泛型，支持管理任意的AIDL接口（所有的AIDL接口都继承自IInterface接口），如下：

public class RemoteCallbackList<E extends IInterface>

它的内部有一个Map接口专门用来保存所有的AIDL回调，这个Map的Key是IBinder类型，value是Callback类型，如下：

ArrayMap<IBinder, Callback> mCallbacks = new ArrayMap<IBinder, Callback>();

其中CallBack封装了真正的远程listener。当客户端注册listener的时候，它会把这个listener的信息存入mCallbacks中，其中key和value分别通过下面的方式获得：

IBinder key = listener.asBinder();
Callback value = new Callback(listnener, cookie);

RemoteCallbackList的使用方式

//创建RemoteCallbackList
private RemoteCallbackList<IAidlListener> mListenerList = new RemoteCallbackList<IAidlListener>();
//添加aidl接口
mListenerList.register(listener);
//删除aidl接口
mListenerList.unregister(listener);

遍历RemoteCallbackList需要用下面的方式进行，beginBroadcast和finishBroadcast必须要配对使用，无论仅仅是获取RemoteCallbackList中元素的个数

final int N = mListenerList.beginBroadcast();
for (int i = 0; i < N; i++) {
    IAidlListener l = mListenerList.getBroadcastItem(i);
    if(l != null) {
        //TODO
    }
}
mListenerList.finishBroadcast();

Binder死亡代理

Binder运行在服务端进程，如果服务端进程由于某种原因异常终止，会导致客户端到服务端的Binder连接断裂（称之为Binder死亡），远程调用就会失败

想要解决这个问题就要使用DeathRecipient，DeathRecipient是系统提供用来监听Binder连接断开的一个接口，它是一个接口内部只有一个方法binderDied，当binder连接断开时就会回调binderDied，然后就可以调用unlinkToDeath移除之前绑定的binder死亡代理

private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
    @Override
    public void binderDied() {
        binder.unlinkToDeath(mDeathRecipient, 0);
        // TODO:这里重新绑定远程Service
    }
};

在客户端绑定远程服务成功后，给binder设置死亡代理

private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName className, IBinder service) {
        service.linkToDeath(mDeathRecipient, 0);
    }
}

还有用Binder的isBinderAlive也可以判断Binder是否死亡

AIDL使用实例

完整使用实例：

https://blog.csdn.net/lj402159806/article/details/85095699

提辖鲁
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android-Binder机制及AIDL使用，实战篇
2401_84520118的博客
04-29 403
学完之后，若是想验收效果如何，其实最好的方法就是可自己去总结一下。比如我就会在学习完一个东西之后自己去手绘一份xmind文件的知识梳理大纲脑图，这样也可方便后续的复习，且都是自己的理解，相信随便瞟几眼就能迅速过完整个知识，脑补回来。下方即为我手绘的Android框架体系架构知识脑图，由于是xmind文件，不好上传，所以小编将其以图片形式导出来传在此处，细节方面不是特别清晰。但可给感兴趣的朋友提供完整的Android框架体系架构知识脑图原件（包括上方的面试解析xmind文档）
Android中的Binder和AIDL
weixin_63261150的博客
08-01 1731
1.Binder1.1简介Binder是一种进程间通信的机。Binder就是Android中的血管，在Android中我们使用Activity,Service等组件都需要和AMS（system_server）进行通信，这种跨进程的通信都是通过Binder完成。Activity,Service等组件和AMS不是同一个进程，其实也是多进程通信。1.2性能Binder相对于传统的Socket方式，更加高效。......
Binder与AIDL的关系
breakloop
03-06 9275
什么是BinderBinder是一个类，它实现了IBinder接口，而IBinder接口定义了与远程对象的交互协议。通常在进行跨进程通信时，不需要实现IBinder接口，直接从Binder派生即可。除了实现IBinder接口外，Binder中还提供了两个重要的接口。（1）Transact()，客户端调用，用于发送调用请求（2）onTransact()，服务端响应，用于接收调用请求因为以上的原因，B...
Android--Binder机制与AIDL
aruba的博客
11-17 1407
关于安卓中的Binder机制，该博客很值得一看：Android Binder设计与实现 - 设计篇，其中深入到了底层原理实现，篇幅很长，需要耐心看完 Binder机制是安卓自己的一套跨进程通信机制，对此需要有进程的概念，Java--线程中有提到进程，当然Linux中自带了很多跨进程通信的方式：管道、消息队列、信号灯、信号、套接字、共享内存，其中很多都因为过时而无人问津了，Binder机制底层使用的...
java Lambda表达式
calabash_man的博客
09-14 173
java Lambda 表达式Lambda表达式定义函数式接口方法引用 Lambda 表达式：传递方法、代码块（函数式编程）。 Lambda表达式定义 Lambda表达式组成：参数，箭头，一个表达式或者多个语句。 例子1： (String first, String second) -> first.length() - second.length() //形参可以不写类型。 //一个形参可以不写括号， //没有形参就保留括号。 //有return 或多个语句一定要接大括号。 //单个语
Android AIDL和Binder机制相关学习总结
张雨的博客
04-06 492
Binder 参考资源 为什么 Android 要采用 Binder 作为 IPC 机制？
Android AIDL Binder 实现与详解 Demo
10-20
Android AIDL Binder 实现与详解。此资源实现了 Android AIDL 通信，自定义 AIDL 数据类型。同时演示了定向 Tag 『inout in out』的区别。并且配有博文详细解释相关知识点以及需要注意的细节。
Android Binder Aidl原理.pdf
12-24
Android Binder的AIDL（Android Interface Definition Language）原理是指Binder机制中使用AIDL语言来定义接口的原理。AIDL是一种IDL（Interface Definition Language），用于定义Binder接口的结构和行为。通过使用...
Android aidl Binder框架浅析
08-16
**Android aidl Binder框架浅析** 在Android系统中，服务间的通信是通过Binder机制实现的，它是Android系统中进程间通信（IPC）的核心组件。Binder框架允许不同进程间的对象互相调用方法，使得数据和操作可以在不同...
Android中AIDL的Binder连接池Demo
10-15
在Android系统中，IPC（Inter-Process Communication）是不同进程之间通信的重要机制，而AIDL（Android Interface Definition Language）则是实现IPC的一种方式。AIDL允许我们定义接口，使得服务可以在不同的进程中...
Android10.0 Binder通信原理(九)-AIDL Binder示例
01-03
摘要：本节主要来讲解Android10.0 Binder中如何使用AIDL 阅读本文大约需要花费20分钟。 文章首发微信公众号：IngresGe 专注于Android系统级源码分析，Android的平台设计，欢迎关注我，谢谢！ [Android取经之路] 的...
不得不说的Android Binder机制与AIDL
smily的博客
08-07 709
说起Android的进程间通信，想必大家都会不约而同的想起Android中的Binder机制。而提起Binder，想必也有不少同学会想起初学Android时被Binder和AIDL支配的恐惧感。但是作为一个Android开发者，Binder是我们必须掌握的知识。因为它是构架整个Android大厦的钢筋和混凝土，连接了Android各个系统服务和上层应用。只有了解了Binder机制才能更加深入的理解Android开发和Android Framework。这也是为什么无论是《Android开发艺术探索》还是《深
一文分析Binder机制和AIDL的理解
nufuli123的博客
03-04 2702
为什么要去理解Android的进程间通信机制 对于Android开发工程师来说，如果不去理解进程间通信机制也可以使用系统提供的API完成应用开发，但如果想要达到更高的层级，那么就不能简单只会调用API。无论是工作中遇到一些疑难问题，还是想要学习源码的一些功能实现，或者是想要提升APP的性能等，这些工作都需要我们去看系统的源码，而系统的源码中进程间通信无处不在，如果不理解进程间通信机制，那么很难看懂系统源码，而且容易迷失在大量的代码中。 Android 进程间通信机制 为什么使用Binder作为Android
不得不说的 Android Binder 机制与 AIDL
chuyouyinghe的专栏
04-03 307
本篇文章主要带大家认识了进程间通信和Binder与AIDL的使用。通过本篇文章的学习可以发现Binder与AIDL其实是非常简单的。了解了Binder之后，我们就可以去更加深入的学习Android Framework层的知识了。作者：赌一包辣条链接：https://juejin.cn/post/6994057245113729038来源：稀土掘金著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
【Android】Binder（一）Binder的介绍和AIDL使用Binder的实例
每天不是在写bug就是在写bug的路上
06-01 3592
Binder的介绍和AIDL使用Binder的实例
Android中的binder和aidl机制
最新发布
easonguolong的博客
07-16 887
在 Android 应用程序中，一般都是通过在 AIDL 文件中定义跨进程访问的接口，并通过 Binder 实现这些接口，从而实现应用程序之间的通信。在android framework中提供了Binder类，一个类如果扩展Binder类，那么该类就有提供远程服务的能力，该类对象一旦创建，其内部就会创建一个隐藏的线程，用来接收binder驱动发送的消息，从而调用Binder类的onTransact()方法。Binder 驱动程序通过管理进程间的连接、数据传输等操作，完成了基于 AIDL 的进程间通信功能。
AIDL与Binder的区别
sunny_girl_11的博客
11-17 6531
Binder是一个远程对象的基础类，核心部分是远程调用机制，这部分是由IBinder定义的。 它是对IBinder类的实现，其中IBinder类提供了这样一个类的标准的本地化实现方式。 大多数开发者不会去直接实现Binder类，而是用AIDL工具来描述他们自己想要的接口，借助它来生成一个合适的Binder之类。 AIDL（Android Interface Define
binder与aidl机制区别
a2758963的专栏
02-07 4578
binder是一个远程对象的基础类，核心部分是远程调用机制，这部分是由IBinder定义的。它是对IBinder类的实现，其中IBinder类提供这样一个类的标准的本地化实现方式。 大多数开发者不会去直接实现Binder类，而是用AIDL工具来描述他们自己想要的接口，借助它来生成一个合适的Binder子类。然而，你也可以直接继承Binder来实现你自定义的RPC协议，或者更简单地，实例化一个原生
Android+ 进程间通信+ Binder驱动原理+ AIDL
09-28
1: 分析IPC通讯：共享内存，Binder, Socket管道 这三种模式的优缺点 2：Binder通讯特点，为什么要用Binder通讯 3：Binder驱动的原理，以及Demo案例来说明Binder通讯数据传输路径 4：在3基础上优化Binder通讯，封装Binder连接，transact()和onTranact()函数封装 5：在4基础上水到渠成 理解AIDL原理

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值