Android实现IPC进程间通信的6种方式 （五）AIDL篇

最新推荐文章于 2021-05-18 16:27:32 发布
最新推荐文章于 2021-05-18 16:27:32 发布
阅读量768 收藏 1
点赞数 1
分类专栏： Android进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34820468/article/details/90445568
版权

接前四篇
基础篇
bundle篇
文件共享篇
Messenger篇

AIDL（ Android Interface Definition Language）Android接口定义语言。上篇中的Messenger其实是一种特殊的AIDL，系统帮我们进行了封装，让我们使用起来更方便快捷。但是Messenger是串行处理消息的，不适合大量并发的情况；并且Messenger只能传递数据，客户端不能调用服务端的方法，而这些AIDL都是可以实现的
本篇我们来用AIDL实现进程间通信
服务端
1）创建我们需要传递数据类的java文件Book，实现Parcelable接口

public class Book implements Parcelable {
    public String name;
    public Book(String name){
        this.name = name;
    }

    protected Book(Parcel in) {
        name = in.readString();
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
    }

    @Override
    public String toString(){
        return " \n Book { " + "name = " + name + "}";
    }
}

2）创建传递数据的AIDL文件。
在对应的目录上，右键就可以创建AIDL文件
在这里插入图片描述
创建的Book.aidl

package aidl.example.com.aidlpractise;

parcelable Book;

注意一下，创建的Book.aidl文件所在的包要与Book.java的包名相同
在这里插入图片描述

3）创建传递方法的AIDL接口
创建的IMyAidlInterface.aidl

package aidl.example.com.aidlpractise;

import aidl.example.com.aidlpractise.Book;

interface IMyAidlInterface {
    void addBook(in String name);//非基本类型数据需要标注in out inout
    List<Book> getBookList();
}

4）build代码，系统自动为我们生成java文件接口
系统为我们创建的java文件目录在app --> build --> genersted --> source --> aidl --> debug --> 接口aidl包名
在这里插入图片描述
打开文件看一下，是这样的

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: D:\\Document\\former\\Demo\\AndroidStudio_demo\\AIDLPractise\\app\\src\\main\\aidl\\aidl\\example\\com\\aidlpractise\\IMyAidlInterface.aidl
 */
package aidl.example.com.aidlpractise;
public interface IMyAidlInterface extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements aidl.example.com.aidlpractise.IMyAidlInterface
{
private static final java.lang.String DESCRIPTOR = "aidl.example.com.aidlpractise.IMyAidlInterface";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an aidl.example.com.aidlpractise.IMyAidlInterface interface,
 * generating a proxy if needed.
 */
public static aidl.example.com.aidlpractise.IMyAidlInterface asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof aidl.example.com.aidlpractise.IMyAidlInterface))) {
return ((aidl.example.com.aidlpractise.IMyAidlInterface)iin);
}
return new aidl.example.com.aidlpractise.IMyAidlInterface.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
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_addBook:
{
data.enforceInterface(DESCRIPTOR);
java.lang.String _arg0;
_arg0 = data.readString();
this.addBook(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_getBookList:
{
data.enforceInterface(DESCRIPTOR);
java.util.List<aidl.example.com.aidlpractise.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements aidl.example.com.aidlpractise.IMyAidlInterface
{
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 addBook(java.lang.String name) 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(name);
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
//非基本类型数据需要标注in out inout

@Override public java.util.List<aidl.example.com.aidlpractise.Book> getBookList() throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List<aidl.example.com.aidlpractise.Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(aidl.example.com.aidlpractise.Book.CREATOR);
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public void addBook(java.lang.String name) throws android.os.RemoteException;

public java.util.List<aidl.example.com.aidlpractise.Book> getBookList() throws android.os.RemoteException;
}

5）服务端创建一个Service来监听客户端的连接请求，并在Service实现AIDL接口
// MyAIDLService.java

public class MyAIDLService extends Service {
    private final String TAG = this.getClass().getSimpleName();

    List<Book> myBookList = null;

    private IBinder mIBinder = new IMyAidlInterface.Stub() {
        @Override
        public void addBook(String name) throws RemoteException {
            myBookList.add(new Book(name));
        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            return myBookList;
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        myBookList = new ArrayList<>();
        Log.d(TAG,"MyAIDLService onBind");
        return mIBinder;
    }
}

到此，我们就把服务端的代码完成了
客户端
客户端要做的事情简单一点
1）绑定服务端的Service
2）绑定成功后，将服务端返回的Binder转换为AIDL接口所属的类型
3）在需要的地方调用AIDL接口的方法实现进程间通信
我是将客户端放在一个Activity中，点击界面的button随机产生一本书，调用addBook()，然后调用getBookList()返回所有的数目列表，显示在TextView中

public class MainActivity extends AppCompatActivity {

    private IMyAidlInterface iMyAidlInterface;
    private LinearLayout layout;
    private TextView textView;
    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        layout = new LinearLayout(getApplicationContext());
        layout.setOrientation(LinearLayout.VERTICAL);
        layout.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
        setContentView(layout);

        textView = new TextView(getApplicationContext());
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        layout.addView(textView);

        button = new Button(getApplicationContext());
        button.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        button.setText("增加一本书");
        layout.addView(button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Random random = new Random();
                String name = "编程"+random.nextInt(10);
                try{
                    iMyAidlInterface.addBook(name);
                    List<Book> lastBookList = iMyAidlInterface.getBookList();
                    textView.setText(lastBookList.toString());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        });

        Intent intent = new Intent(getApplicationContext(),MyAIDLService.class);
        bindService(intent,serviceConnection,BIND_AUTO_CREATE);
    }

    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            iMyAidlInterface = null;
        }
    };
}

Manifest文件
最后在Manifest文件中将service和activity放在不同的进程中

<service
    android:name=".MyAIDLService"
    android:enabled="true"
    android:exported="true"
    android:process="android.aidl.service" />

<activity
    android:name=".MainActivity"
    android:process="android.aidl.client">
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
</activity>

运行结果
在这里插入图片描述我们目前实现了客户端主动请求服务端，添加和查询书籍。但是实际中我们更希望服务端在有了新书的时候，主动提醒我们新书到了，这种观察者模式要怎么实现呢，下面我们来看看
首先我们需要定义一个OnNewBookArrivedListener的接口，在接口中我们将利用方法newBookArrived将新书发送给订阅者们
//OnNewBookArrivedListener

package aidl.example.com.aidlpractise;

import aidl.example.com.aidlpractise.Book;

interface OnNewBookArrivedListener {
    void newBookArrived(in Book newBook);
}

接下来我们修改IMyAidlInterface.aidl，我们添加订阅和取消订阅接口OnNewBookArrivedListener的分两个方法
//IMyAidlInterface .aidl

package aidl.example.com.aidlpractise;

import aidl.example.com.aidlpractise.Book;
import aidl.example.com.aidlpractise.OnNewBookArrivedListener;

interface IMyAidlInterface {
    void addBook(in String name);
    List<Book> getBookList();
    void registerListener(OnNewBookArrivedListener listener);
    void unRegisterListener(OnNewBookArrivedListener listener);
}

然后我们肯定要修改MyAIDLService的mIBinder，并添加一个循环来模拟新书到来，具体代码如下
//MyAIDLService

public class MyAIDLService extends Service {
    private final String TAG = this.getClass().getSimpleName();
    private RemoteCallbackList<OnNewBookArrivedListener> listeners;//跨进程listener接口要用RemoteCallbackList

    List<Book> myBookList = null;

    private IBinder mIBinder = new IMyAidlInterface.Stub() {
        @Override
        public void addBook(String name) throws RemoteException {
            myBookList.add(new Book(name));
        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            return myBookList;
        }

        @Override
        public void registerListener(OnNewBookArrivedListener listener) throws RemoteException {
                listeners.register(listener);
                Log.d(TAG,"registerListener");
        }

        @Override
        public void unRegisterListener(OnNewBookArrivedListener listener) throws RemoteException {
            listeners.unregister(listener);
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        myBookList = new ArrayList<>();
        listeners = new RemoteCallbackList<>();
        Log.d(TAG,"MyAIDLService onBind");
        refreshNewBook();
        return mIBinder;
    }

    private Timer timer = new Timer();
    private TimerTask timerTask = new TimerTask() {
        @Override
        public void run() {
            try {
                int N = listeners.beginBroadcast();
                for(int i=0; i< N; i++){//RemoteCallbackList比需采用这种方式遍历
                    OnNewBookArrivedListener listener = listeners.getBroadcastItem(i);
                    listener.newBookArrived(new Book("新书" + new Random().nextInt(10)));
                    Log.d(TAG, "new book arrived");
                }
            }catch (RemoteException e) {
                e.printStackTrace();
            }finally {
                listeners.finishBroadcast();
            }
        }
    };

    private void refreshNewBook() {
        timer.schedule(timerTask,100,2000);
    }
}

接下来就是在客户端添加OnNewBookArrivedListener的监听了
//MainActivity

public class MainActivity extends AppCompatActivity{

    private IMyAidlInterface iMyAidlInterface;
    private LinearLayout layout;
    private TextView textView;
    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        layout = new LinearLayout(getApplicationContext());
        layout.setOrientation(LinearLayout.VERTICAL);
        layout.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
        setContentView(layout);

        textView = new TextView(getApplicationContext());
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        layout.addView(textView);

        button = new Button(getApplicationContext());
        button.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
        button.setText("增加一本书");
        layout.addView(button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Random random = new Random();
                String name = "编程"+random.nextInt(10);
                try{
                    iMyAidlInterface.addBook(name);//客户端访问服务端方法，客户端会挂起，尽量放在非主线程中
                    List<Book> lastBookList = iMyAidlInterface.getBookList();//客户端访问服务端方法，耗时，尽量放在非主线程中
                    textView.setText(lastBookList.toString());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        });

        Intent intent = new Intent(getApplicationContext(),MyAIDLService.class);
        bindService(intent,serviceConnection,BIND_AUTO_CREATE);
    }

    private OnNewBookArrivedListener onNewBookArrivedListener = new OnNewBookArrivedListener.Stub() {
        @Override
        public void newBookArrived(Book newBook) throws RemoteException {
            if(textView != null) {
                iMyAidlInterface.addBook(newBook.name);
                List<Book> lastBookList = iMyAidlInterface.getBookList();
                Message message = new Message();
                message.obj= lastBookList.toString();
                message.what = 0;
                handler.sendMessage(message);
            }
        }
    };

    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg){
            switch (msg.what){
                case 0:
                    textView.setText(msg.obj.toString());
            }
        }
    };

    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
            try {
                iMyAidlInterface.registerListener(onNewBookArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            iMyAidlInterface = null;
        }
    };

    @Override
    public void onDestroy(){
        try {
            iMyAidlInterface.unRegisterListener(onNewBookArrivedListener);
            unbindService(serviceConnection);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        super.onDestroy();
    }
}

接下来我们运行代码

在这里插入图片描述
到这里我们就把AIDL的基础知识学习完了

下一篇 ContentProvider实现进程间通信

特别感谢《Android 开发艺术探索》

夏日韵律
关注
专栏目录
Android 进程间通信——AIDL
奋斗的菜鸟ing
01-12 2814
AIDL(Android Interface Definition Language)——进程间通信的一种机制。它允许您定义客户端和服务端通过使用进程间通信（IPC）进行通信的编程接口。在Android上，一个进程无法正常访问另一个进程的内存。所以说，他们需要将他们的对象分解成操作系统能够理解的原语，并且把这些对象放在你的边界上。编写这些代码非常繁琐，所以Android使用AIDL来处理它。 D
Android IPC进程间通信详解最新AndroidStudio的AIDL操作)
01-04
》 ，这些都是在同一个进程中，那进程间的通信，或者说不同的应用间的通信该如何实现呢？这个时候就要用到AIDL(Android Interface Definition LanguageAndroid接口定义语言 )。 使用方法（AndroidStudio） 我发现...
Android进程间通信方式总结（IPC）
bill_sha的专栏
09-15 5960
第一种：Intent方式 Intent分为两种，一种是显式Inten
Android进程间通信方式总结
yangmian1024的博客
04-03 247
Android进程间通信Android进程间通信方式一、使用 Intent二、使用 Messenger三、使用 AIDL四、使用 ContentProvider Android进程间通信方式 一、使用 Intent Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle实现了Parcelable 接口，可以在不同的进程间进行...
Android进程间通信（四）：进程间通信的方式之AIDL
103style
10-30 501
转载请以链接形式标明出处： 本文出自:103style的博客 《Android开发艺术探索》 学习记录 base on AndroidStudio 3.5.1 目录 前言 AIDL接口创建 AIDL支持的数据格式 服务端实现 创建 BookManagerService.java 处理并发情况 客户端实现 创建 BookManagerActivity.java 运行程序查看日志 ...
Android——IPC机制（二）进程间通信方式
AkaiC的博客
09-20 2282
在上一章中，我们已经介绍了IPC的几个基础知识：序列化和Binder，本章将详细介绍各种跨进程同行方式。具体的方式有很多，比如可以通过在Intent中附加extras来传递信息，或者通过共享文件的方式来共享数据，还可以采用Binder的方式来跨进程通信，另外ContentProvider天生就是支持跨进程访问的，隐藏我们也可以采用它来进行IPC。此外通过网络通信也是可以实现数据传递的，所以Socke
Android AIDL实现进程间通信探索
09-01
Android AIDL（Android Interface Definition Language）是Android系统提供的一种进程间通信（IPC, Inter-Process Communication）机制，它允许不同进程之间的应用程序组件相互调用方法，实现数据交换。在Android中...
Android 进程间通信AIDL使用详解
08-29
"Android 进程间通信AIDL使用详解" Android 进程间通信（IPC）是一种复杂的技术，AIDL（Android Interface Definition Language）是 Android 系统中的一种进程间通信机制。AIDL 是一种描述语言，用于定义服务器和...
详解Android 进程间通信的几种实现方式
08-31
在Android系统中，进程间通信（IPC，Inter-Process Communication）是实现不同应用程序之间数据交换的关键技术。Android SDK为开发者提供了四种主要的IPC方式，分别是：Activity、Content Provider、Broadcast和...
android进程间通信(IPC)的多种方式
xingkong_hdc的博客
12-20 523
1.进程与线程什么是进程，在计算机系统内进程是包括I/O，虚拟内存，处理器在内的一种抽象概念，通常情况下，一个程序就是一个进程。在Android应用程序中可以给四大组件指定android：process属性来创建多线程。什么是线程，线程是CPU调度的最小单元，是一种有限的系统资源。线程包含在进程内，一个进程可以有多个线程，也可以只有单一线程，即主线程。同一进程内的线程共享代码和数据，而不同进程，处于
android中进程间通讯的两种方法
a3015440的专栏
06-11 2183
<br />android中没有提供一种很方便的进程间通讯的方法，之前为了实现这个功能多用content provider来实现，本质上讲，就是使用了android的内部的sqlite数据库，一个进程负责查询，一个负责改变表项状态，借助数据库的四个特性（ACID）来实现进程间消息状态传递的功能，而这个RPC则为我们提供了另一种进程间通信的方法。
Android进程间通信(IPC)常用方式
人王的专栏
03-30 6364
进程间通信方式在Android开发中我们可以通过Intent、ContentProviders来实现进程间通信，如果不限于Android特有的话，我们还可以使用File、Socket等方式，反正只要进程间能交换信息就行了。像Intent，我们平时使用的时候好像都没感觉出是在进程间通信。其实Android中进程间的通信是非常频繁的，应用里打开一个新的Activity都涉及到了进程间通信，应用里调用打电
Android IPC 进程间通信
Dream It Possible
07-20 6745
IPC （进程间通信）本文转自：http://blog.csdn.net/lisdye2/article/details/51775856博客导读：什么是IPCIPC(Inter-Process Communication) 进程间通信，是指两个不同进程之间数据交换的过程。在明确其之前，需要先搞懂几个概念: 线程：CPU可调度的最小单位，是程序执行流的最小单元；线程是进程中的一个实体，是被系统独立调
Android进程间通信的方式
w517272812的博客
03-20 200
一、使用 Intent Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle 实现了 Parcelable 接口，可以在不同的进程间进行传输。 在一个进程中启动了另一个进程的 Activity，Service 和 Receiver ，可以在 Bundle 中附加要传递的数据通过 Intent 发送出去。 二、使用文件共享 Wind...
Android进程间通信方式
u012845099的博客
05-18 365
一Intent Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle 实现了 Parcelable 接口，可以在不同的进程间进行传输。 Bundle bundle = new Bundle(); bundle.putString("test", "来自A"); Intent intent = new Intent(Intent.ACTION_MAIN); intent.addCategory(Intent.
android进程间通信-AIDL
gengbaolong的博客
03-21 505
Android进程间通信可以参考android-进程间通信 这里着重介绍一下AIDL。 这里只是记录一下我自己的实现过程，例子本身不重要，重要的是知道怎么做。。。 总体来说分三步：创建AIDL，创建服务端，创建客户端。 一、创建AIDL 1.在java目录下创建一个包名com.ps.sevenaidldemo.aidl（随便取），然后创建Book.java实体类，这个实体类必须实现Par...
Android进程间通信之AIDL
weixin_33921089的博客
12-15 97
本文例子中的源码地址： Github：进程间通信之AIDL AIDL（Android 接口定义语言）是定义客户端与服务使用进程间通信 (IPC) 进行相互通信时都认可的编程接口，一个进程通常无法访问另一个进程的内存，但是可以通过AIDL进行进程间通信。**AIDL可以让客户端以IPC(进程间通信)方式访问服务端，并且服务端可以处理多线程；如果不需要处理多线程，则可以使用Messenger类来实现接...
Android进程间通讯之AIDL
Ricky 的博客
08-15 1053
Android AIDL的使用什么是AIDL？AIDL是Android Interface Definition Language 的英文缩写，，通过AIDL定义的程序接口可以实现服务端与客户端的通信。其实所谓的服务端跟客户端都是我们开发的APP，我们可以简单理解为，其中一个APP提供服务数据，另一个APP可以去获取数据服务提供的数据。我们知道两个APP分属于两个不同的进程，所以说AIDL是用于An
理解Android AIDL：进程间通信实现与应用
"Android进程间通信实现原理分析，主要讲解了Android Service的分类，本地服务与远程服务的区别，以及AIDL（Android Interface Definition Language）在远程服务中的应用，用于实现进程间通信（IPC）。" Android...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值