安卓折叠视图

最新推荐文章于 2021-05-27 15:31:46 发布
最新推荐文章于 2021-05-27 15:31:46 发布
阅读量608 收藏
点赞数
分类专栏： 安卓 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u010431205/article/details/51556865
版权

安卓折叠视图

上一篇博客写的是侧滑菜单,这篇就写个会折叠的菜单,先上效果图:
这里写图片描述
这里写图片描述
这里写图片描述
好骚是不是= =

package xiaolin.widget;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PaintFlagsDrawFilter;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Scroller;

import xiaolin.utils.Utils;

/**
 * Created by Administrator on 2016/1/14.
 */
public class AFoldingPaneLayer extends ViewGroup {

    public static final String TAG = "AFoldingPaneLayer";
    public static final int MININERCEPTXVILOCITY = 8;   // 最小拦截速度（dp）
    public static final int MINTOUCHVILOCITY = 300;     // 最小触发速度（dp）
    private static final int drawerTime = 400;          // 动画时间

    private Scroller mScroller = null;
    private VelocityTracker velocity = null;
    private Paint paint = new Paint();
    private Paint mPaintShadow = new Paint();
    private Bitmap bitmapFull = null;
    private AFoldingListener listener = null;

    private int menuWidth = 0;        // 菜单宽度
    private boolean mIsOpenFolding = false;     // 是否显示抽屉
    private boolean isTouchRight = false;
    private boolean isBeingDragged = false;
    private boolean isUnableToDrad = false;
    private boolean mIsUpdateBitmap = true;
    private float lastInerceptX = 0;
    private float lastInerceptY = 0;
    private float lastTouchX = 0;
    private float firstTouchX= 0;
    private int mNumberOfFolds = 2;

    public AFoldingPaneLayer(Context context) {
        super(context);
        init(context);
    }

    public AFoldingPaneLayer(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    public AFoldingPaneLayer(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(context);
    }

    private void init(Context context){
        mScroller = new Scroller(context);
        paint.setAntiAlias(true);
        paint.setDither(true);

        mPaintShadow.setColor(Color.BLACK);
        mPaintShadow.setStyle(Paint.Style.FILL);
    }

    @Override
    // 布局测量
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        setMeasuredDimension(width, height);
        menuWidth= (int)(width*0.75f);         // 菜单宽度
        if(bitmapFull != null){
            bitmapFull.recycle();
            bitmapFull = null;
        }
        bitmapFull = Bitmap.createBitmap(width+menuWidth, height, Bitmap.Config.ARGB_8888);
        mIsUpdateBitmap = true;
        int childCount = getChildCount();
        if(childCount < 1){
            return;
        }
        View menuView = getChildAt(0);
        // 合成菜单的测量宽度
        int menuWidthSpec = MeasureSpec.makeMeasureSpec(menuWidth, MeasureSpec.EXACTLY);
        menuView.measure(menuWidthSpec, heightMeasureSpec);
        for(int i=1; i<childCount; i++){
            View childView1 = getChildAt(i);
            childView1.measure(widthMeasureSpec, heightMeasureSpec);
        }
    }

    @Override
    /*布局，设置字控件的位置*/
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        int childCount = getChildCount();
        if(childCount <1){
            return;
        }
        // 隐藏在左边的视图
        View menuView = getChildAt(0);
        // 设置子视图的位置，左上角坐标，宽高
        menuView.layout(-menuView.getMeasuredWidth(), 0, 0, menuView.getMeasuredHeight());

        int left = 0;
        for(int i=1; i<childCount; i++) {
            View childView = getChildAt(i);
            int w = childView.getMeasuredWidth();
            childView.layout(left, 0, left+w, childView.getMeasuredHeight());
            left += w;
        }
    }

    @Override
    // onDraw()函数会调用此函数
    public void computeScroll() {
        if(mScroller.computeScrollOffset()){
            int x = mScroller.getCurrX();
            scrollTo(x, 0);
            // 调用invalidate()无效
            postInvalidate();
            if(listener != null){
                listener.progress(-x/menuWidth);
            }
        }
    }

    /**
     * 矩阵变换
     * @param rect_src 源
     * @param rect_dst 目标
     * @param deep     深度
     * @param isScaleLeft 在左边还是在右边
     * @return
     */
    private Matrix calculate(Rect rect_src, Rect rect_dst, int deep, boolean isScaleLeft){
        float src[] = new float[]{
                rect_src.left, rect_src.top,      // 左上
                rect_src.right, rect_src.top,     // 右上
                rect_src.right, rect_src.bottom,  // 右下
                rect_src.left, rect_src.bottom    // 左下
        };
        float[] dst = null;
        if(isScaleLeft) {
            dst = new float[]{
                    rect_dst.left, rect_dst.top+deep,
                    rect_dst.right, rect_dst.top,
                    rect_dst.right, rect_dst.bottom,
                    rect_dst.left, rect_dst.bottom-deep
            };
        }else{
            dst = new float[]{
                    rect_dst.left, rect_dst.top,
                    rect_dst.right, rect_dst.top + deep,
                    rect_dst.right, rect_dst.bottom - deep,
                    rect_dst.left, rect_dst.bottom
            };
        }
        Matrix matrix = new Matrix();
        matrix.setPolyToPoly(src, 0, dst, 0, src.length >> 1);
        return matrix;
    }

    /*绘制子视图*/
    @Override
    protected void dispatchDraw(Canvas canvas) {
        int x = getScrollX();
        if(x >= 0 || mNumberOfFolds==0){
            super.dispatchDraw(canvas);
            return;
        }
        canvas.setDrawFilter(new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG
                | Paint.FILTER_BITMAP_FLAG));// 画布抗锯齿
        if(-x == menuWidth || mIsUpdateBitmap){
            bitmapFull.eraseColor(Color.argb(0, 0, 0, 0));
            // 将所有像素设为透明
            Canvas canvas1 = new Canvas(bitmapFull);
            canvas1.translate(menuWidth, 0);
            // 平移到正确位团置
            super.dispatchDraw(canvas1);
            // 把视图全部画到位图上
            if(mIsUpdateBitmap){
                mIsUpdateBitmap = false;
                /*画上阴影*/
            }
        }

        int height = getHeight();
        if(-x != menuWidth) {   /*以折叠形式绘制菜单*/
            float dstX = x;
            float dstW = Math.abs((float) x / mNumberOfFolds);
            float srcX = 0;
            float srcW = Math.abs((float) menuWidth / mNumberOfFolds);
            int depth = (int)Math.sqrt(Math.pow(srcW, 2)-Math.pow(dstW, 2))/6;// 勾股定理，再缩小几倍
            for (int i = 0; i < mNumberOfFolds; i++) {
                Rect rect_src = new Rect((int) srcX, 0, (int) (srcX + srcW), height);
                Rect rect_dst = new Rect((int) dstX, 0, (int) (dstX + dstW), height);
                Matrix matrix = calculate(rect_src, rect_dst, depth, i%2==1);
                canvas.save();
                canvas.clipRect(rect_dst);
                canvas.concat(matrix);
                canvas.drawBitmap(bitmapFull,0, 0, paint);
                if(i%2==1){
                    mPaintShadow.setAlpha(128-128*-x/menuWidth);
                    canvas.drawRect(rect_src, mPaintShadow);
                }
                canvas.restore();
                dstX += dstW;
                srcX += srcW;
            }
        }else{  /*直接绘制菜单*/
            canvas.save();
            canvas.clipRect(-menuWidth, 0, 0, height);
            super.dispatchDraw(canvas);
            canvas.restore();
        }

        /*绘制右边的主内容*/
        Rect rect_src = new Rect(0, 0, this.getWidth(), height);
        Rect rect_dst = new Rect(0, 0, this.getWidth()+x, height);
        Matrix m = calculate(rect_src, rect_dst, -x / 8, false);
        m.preTranslate(-menuWidth, 0);
        canvas.save();
        canvas.clipRect(rect_src);
        canvas.drawBitmap(bitmapFull, m, paint);
        canvas.restore();
    }

    /**
     * 只要您在onInterceptTouchEvent方法中返回false,
     * 每个后续的事件(从当前事件到最后ACTION_UP事件)将会先分发到onInterceptTouchEvent中，
     * 然后再交给目标子控件的onTouchEvent处理 （前提是子控件的onTouchEvent返回是true ）。
     *
     * 如果在onInterceptTouchEvent返回true，
     * onInterceptTouchEvent方法中将不会收到后续的任何事件，
     * 目标子控件中除了ACTION_CANCEL外也不会接收所有这些后续事件，
     * 所有的后续事件将会被交付到你自己的onTouchEvent()方法中。
     * @param event
     * @return
     */
    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        int action = event.getAction();
        if(action != 0){
            if(isBeingDragged){
                return true;
            }
            if(isUnableToDrad){
                return false;
            }
        }
        if(action == MotionEvent.ACTION_DOWN){
            lastInerceptX = event.getX();
            lastInerceptY = event.getY();
            isBeingDragged = false;
            isUnableToDrad = false;
            if(!mScroller.isFinished()){
                mScroller.abortAnimation();
                return true;
            }else if(mIsOpenFolding){
                if(event.getX()>menuWidth){
                    isBeingDragged = true;
                }
            }
        }else if(action == MotionEvent.ACTION_MOVE) {
            float x = event.getX();
            float y = event.getY();
            float dx = Math.abs(x-lastInerceptX);
            float dy = Math.abs(y-lastInerceptY);
            if(dy>dx) {  // 上下滑动
                isUnableToDrad = true;
            }else if(x<lastInerceptX && !mIsOpenFolding) { // 往左滑动&&已关窗
                isUnableToDrad = true;
            }else if(x>lastInerceptX && mIsOpenFolding){    // 往右滑动&&已开窗
                isUnableToDrad = true;
            }else if(dx>dy && dx> Utils.dpToPx(MININERCEPTXVILOCITY, getResources())){  // 往右并且大于一定速度
                isBeingDragged = true;
            }
            lastInerceptX = x;
            lastInerceptY = y;
        }
        return isBeingDragged;
    }

    // 触摸事件
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        int action = event.getAction();
        float x = event.getX();
        if(velocity == null){
            mIsUpdateBitmap = true;
            velocity = VelocityTracker.obtain();
            lastTouchX = x;
            if(mIsOpenFolding && x>menuWidth){
                isTouchRight = true;
                firstTouchX = x;
            }else{
                isTouchRight = false;
            }
        }
        velocity.addMovement(event);
        if(action == MotionEvent.ACTION_DOWN){// 可能无此动作

        }else if(action == MotionEvent.ACTION_MOVE){ // 正在滑动
            float dx = x-lastTouchX;
            drawerViewBy((int)dx);
            lastTouchX = x;
        }else if(action == MotionEvent.ACTION_UP){
            if(isTouchRight && firstTouchX==x){
                closeFolding();
                velocity.recycle();
                velocity = null;
                return true;
            }else{
                velocity.computeCurrentVelocity(1000);
                if(velocity.getXVelocity() < -Utils.dpToPx(MINTOUCHVILOCITY, getResources())){
                    closeFolding();
                }else if(velocity.getXVelocity() > Utils.dpToPx(MININERCEPTXVILOCITY, getResources())){
                    openFolding();
                }else{
                    if(-getScrollX()>menuWidth/2){
                        openFolding();
                    }else{
                        closeFolding();
                    }
                }
                velocity.recycle();
                velocity = null;
            }
        }
        return true;
    }

    @Override
    // 按键监听
    public boolean dispatchKeyEvent(KeyEvent event) {
        int code = event.getKeyCode();
        int action = event.getAction();
        if(code==KeyEvent.KEYCODE_BACK && action==KeyEvent.ACTION_UP){
            if(mIsOpenFolding){
                closeFolding();
                return true;
            }
        }
        return super.dispatchKeyEvent(event);
    }

    // 滚动距离并判断范围
    private void drawerViewBy(int dx){
        dx = -dx;
        int x = getScrollX();
        if(x+dx>0){
            scrollTo(0, 0);
        }else if(x+dx < -menuWidth){
            scrollTo(-menuWidth, 0);
        }else {
            scrollTo(x + dx, 0);
        }
        if(listener != null){
            listener.progress(-getScrollX()/(float)menuWidth);
        }
    }

    // 设置窗格数量
    public void setNumberOfFolds(int numberOfFolds){
        this.mNumberOfFolds = numberOfFolds;
    }

    public int getNumberOfFolds(){
        return mNumberOfFolds;
    }

    // 关闭菜单
    public void closeFolding(){
        int x = getScrollX();
        mScroller.startScroll(x, 0, -x, 0, drawerTime);
        invalidate();
        mIsOpenFolding = false;
        if(listener != null) {
            listener.fold(mIsOpenFolding);
        }
    }

    // 打开菜单
    public void openFolding(){
        int x = getScrollX();
        mScroller.startScroll(x, 0, -menuWidth - x, 0, drawerTime);
        invalidate();
        mIsOpenFolding = true;
        if(listener != null){
            listener.fold(mIsOpenFolding);
        }
    }

    // 是否打开菜单
    public boolean isOpen(){
        return mIsOpenFolding;
    }

    // 设置监听
    public void setFoldingListener(AFoldingListener listener){
        this.listener = listener;
    }

    // 监听接口
    public interface AFoldingListener{
        public void fold(boolean isOpen);
        public void progress(float progress);// 0.0f-1.0f
    }

}

package xiaolin.utils;

import android.content.res.Resources;
import android.util.TypedValue;

/**
 * Created by Administrator on 2016/1/17.
 */
public class Utils {

    private Utils(){

    }

    /**
     * dp转为像素
     * @param dp
     * @param resources
     * @return
     */
    public static float dpToPx(float dp, Resources resources){
        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, resources.getDisplayMetrics());
    }
}

在xml里使用

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="#ffffff"
    android:orientation="vertical">

    <xiaolin.widget.AFoldingPaneLayer
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/layout">

        <!-- 菜单部分 -->
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:background="#ffffff"
            android:orientation="vertical">

            <ImageView
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:src="@drawable/img_bg"
                android:scaleType="centerCrop"/>

        </LinearLayout>

        <!-- 内容部分 -->
        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:background="@color/colorPrimary"
            android:orientation="vertical"
            android:gravity="center">

            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="小林"
                android:textColor="#ffffff"
                android:textSize="20sp"/>

        </LinearLayout>

    </xiaolin.widget.AFoldingPaneLayer>

</LinearLayout>

在Activity里使用

package xiaolin.widget;

import android.app.Activity;
import android.os.Bundle;

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        AFoldingPaneLayer layer = (AFoldingPaneLayer)findViewById(R.id.layout);
        layer.setNumberOfFolds(4);// 设置有四个窗格,默认有两个窗格
    }

}
Android 图片慢慢展开、慢慢折叠与向下展开的功能？
yyxhzdm的博客
09-16 1076
实现的的效果 描述：一开始是完全显示的，然后高度慢慢减少，图片自上而下消失。还有就是左右慢慢展开 分析：这个效果看似很简单，但是实际上根据常规的android机制，是很难以实现的。 解决方案 想了很久，突然联想到MeasureSpec的三种情况（自适应，合父布局一样和绝对大小）。感觉图像设置为绝对大小并且靠底部对齐。然后自上而下减少外布局高度，应该可以实现效果。 一、慢慢折叠与向下展开动画 1.自定义绝对大小的Imageview package com.ruidde.csndreso
android内容页折叠,CoordinatorLayout页面折叠控件
weixin_35385462的博客
06-03 919
简介CoordinatorLayout是一种嵌套滑动控件，结合AppbarLayout, CollapsingToolbarLayout等 可 产生各种炫酷的折叠悬浮效果。本文参考文章CoordinatorLayout 学习(一) - CoordinatorLayout的基本使用使用作为最上层的View作为一个 容器与一个或者多个子View进行交互AppBarLayout如果我们想要实现折叠的Ac...
Android可扩展/可折叠视图
04-03 405
Android可扩展/可折叠视图 当我们希望在一个屏幕上显示所有可用选项时，无需用户一直滚动以查找他/她感兴趣的选项，则Android中的可扩展/可折叠视图（文本，图像等）非常有用。我们正在尝试通过提供其内容的整体视图来最大程度地利用屏幕上的可用空间。 Android SDK提供了ExpandableListView类，但有时该选项过高或不符合我们的意图和目的，我们可能决定推出自己的机制。 ...
Android Folding View（折叠视图、控件）
weixin_34174105的博客
01-21 160
  版本号：1.0日期：2014.4.21版权：© 2014 kince 转载注明出处非常早之前看过有人求助以下这个效果是怎样实现的，  也就是側滑菜单的一个折叠效果，事实上关于这个效果的实现，谷歌的一名project师已经完毕。并开放源代码到devbytes上面了。如以下所看到的：  地址是： https://android.googlesource.com/platform/develop...
领歌敏捷协作——显示折叠视图
简简单单Onlinezuozuo
05-20 4110
文章目录领歌敏捷协作——显示折叠视图1、选择并进入一个看板2、使用折叠视图 领歌敏捷协作——显示折叠视图 1、选择并进入一个看板 2、使用折叠视图 点击红框所示位置，进入折叠视图 折叠视图如图所示 通过折叠视图，我们可以快速的查看整个看板的总览 ...
可折叠日历视图Android：可折叠日历视图是一个简单的日历视图，可以折叠以节省空间，并且可以在需要时进行扩展
02-03
implementation ' com.github.shrikanth7698:Collapsible-Calendar-View-Android:v1.0.3 ' } Maven 将JitPack存储库添加到您的构建文件中 < id> jitpack . io < / id > < url> ...
Android-在简单的日历视图中可折叠的CalendarView
08-12
在Android开发中，创建一个可折叠的CalendarView可以极大地提升用户体验，尤其是在有限的屏幕空间上。这个"在简单的日历视图中可折叠的CalendarView"项目，正如其标题所描述，提供了一种创新的方式，使得用户可以在...
Expandablecollapse：带齐射的可展开折叠视图
02-18
在Android开发中，可展开折叠视图（ExpandableCollapse）是一种常见的用户界面元素，它允许用户隐藏或显示分组的数据，提高用户交互性和界面的可读性。标题和描述提到的"带齐射的可展开折叠视图"可能是指在展开和...
android折叠view
10-18
"android折叠view"这个话题涉及到Android自定义View的概念，以及如何通过编程来实现这样的交互效果。本文将深入探讨如何在Android中创建一个可折叠的View。 首先，理解Android的自定义View机制是至关重要的。自定义...
android实现图片向上展开和慢慢折叠的过度动画
毕业生笔记的博客
12-16 3181
需要实现的的效果 描述：一开始是完全显示的，然后高度慢慢减少，图片自上而下消失。 分析：这个效果看似很简单，但是实际上根据常规的android机制，是很难以实现的。 常规方案 Imageview变化大小，只会整体压缩，不可行 外布局一个RelativeLayout,Imageview靠底部对齐，然后自上而下减少外布局高度，也会压缩图像，还是不可行 用一个空白的布局慢慢遮挡图片，实现...
android折叠布局,Android中FoldingLayout折叠布局的用法及实战全攻略
weixin_35813719的博客
05-26 1373
一、概述无意中翻到的FoldingLayout的介绍的博客，以及github地址。感觉很nice呀，于是花了点时间研究以及编写，本篇博客将带大家从最基本的原理分析，一步一步的实现我们的FoldingLayout，当然了，如果你能力过硬，可以直接下载github上的代码进行学习。博客基本分为以下几个部分：1、Matrix的setPolyToPoly使用2、在图片上使用渐变和阴影3、初步的Foldin...
android 折纸效果,android给RecyclerView加上折叠的效果示例
weixin_33931886的博客
05-27 935
RecyclerView有很高的自由度，可以说只有想不到没有做不到，真是越用越喜欢。这次用超简单的方法，让RecyclerView带上折叠的效果。效果是这样的。总结一下这个列表的特点，就是以下三点：1. 重叠效果；2. 层次感；3. 首项的差动效果。下面我们来一个个解决。我们新建一个ParallaxRecyclerView，让它继承RecyclerView，并使用LinearLayoutManag...
android实现折叠动画,Android开发之自定义View-可动画展开收缩View的实现
weixin_28684757的博客
05-26 1558
有时候需要点击一个view可以动画展开和收缩折叠一个View这样的效果，这样就可以直接自定义View来实现。本例中，采用继承FrameLayout来实现自定义的ExpandView。下面将详细介绍各个部分来实现该类以及如何使用该自定义视图。效果图如下：未展开效果：正在向上折叠收缩中的效果：已经展开效果：自定义展开类：ExpandView的实现：packagecom.czm.customview;i...
android可折叠窗口,Android Studio使用recyclerview实现展开和折叠功能（在之前的微信页面基础之上）...
weixin_35656458的博客
05-26 808
Android中RecyclerView点击item展开列表详细内容效果如下：依然是xml文件的设计，使用了两个RelativeLayout，zu作为主布局和副布局，里面都加入textview显示内容，在副布局里加入一个imageview在这里插入图片描述作为子内容的背景图，代码如下：tab01.xmlxmlns:app="http://schemas.android.com/apk/res-au...
自定义可折叠展开的LinearLayout
zhaonhui的博客
08-27 1857
本篇文章记录一下自定义的可以简单进行折叠展开的LinearLayout，只支持竖直方向，如果需要水平方向的，对宽度进行操作即可。测试效果时，包含的子View是个TextView，也可以是其他的子View。下面是效果图： 实现的思路是继承LinearLayout，并重写onMeasure动态的控制高度以达到效果，代码如下： package cn.znh.expandlinearlayou...
Android RecycleView 分类和折叠显示
nightwizard2030的博客
11-07 5310
在使用recycleview的时候，外层最好是不要有scrollview，或者说是不能，不然会发生冲突。仔细想想recycleview的wrap_content 并不代表着根据内容自适应高度，它的高度应和屏幕高度保持一致，然后才能去重复利用view，所以你把recycleview撑开了的话，再使用scrollview去滚动，就失去了本身的意义。所以，实现一定是用1个recycleview去包裹住所
android 折叠与展开,android – 如何根据滚动方向折叠/展开视图？
weixin_34456923的博客
05-27 387
您必须将协调器布局与CollapsingToolbarLayout一起使用xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"android:layout_width="match_parent"android:layout_heig...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值