Android onMeasure()测量流程解析

于 2021-08-16 19:57:20 发布
阅读量1.5k 收藏 1
点赞数 1
文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43864176/article/details/119740265
版权

Android onMeasure()测量流程解析

文章目录

前言

众所周知，Android 中组件显示到屏幕上需要经历测量、布局、绘制三个阶段，我们今天来了解一下测量的流程。

布局与绘制流程文章

Android onLayout()布局流程解析
Android onDraw()绘制流程解析

组件测量的那些结论

先看结论再看分析

1. ）测量流程的起点是ViewRootImpl的PerformTraveals()方法 ，该方法调用performMeasure（）方法，performMeasure（）方法会调用根View（DecorView）的measure（）方法，开启测量流程。也就是说测量流程是从根View开始的，准确来说是从根View的measure（）方法开始的。因为根View是ViewGroup（FrameLayout）,所以测量流程是从ViewGroup开始的。

2. )View 类有默认的onMeasure（）实现，如果我们想实现自己的测量，需要重写onMeasure（）方法。
根View（DecorView）是ViewGroup（FrameLayout）， ViewGroup类继承自View类，View类的measure(int widthMeasureSpec, int heightMeasureSpec) 方法会调用onMeasure(widthMeasureSpec, heightMeasureSpec)方法，根据自身规则测量自己的宽高。而ViewGroup类并没有重写其父类View的onMeasure方法，Android提供给我们的系统组件（比如FrameLayout、LinearLayout等等）和我们自定义继承自View或ViewGroup的组件，一般都需要重写onMeasure（）方法，如果不重写onMeasure（）方法，组件是默认填满父布局的。

3. ) 对于根View（DecorView），其MeasureSpec由窗口的尺寸和其自身的LayoutParams共同决定的，对于普通View，其MeasureSpec由父容器的MeasureSpec和自身的LayoutParams共同决定的。

4. ) 自定义的ViewGroup测量一般会循环自身所有的子View，调用相应的方法（measureChildWithMargins（）、measureChildren方法，这两个方法都会调用getChildMeasureSpec（）方法）根据自己的MeasureSpec和子View的ViewGroup.LayoutParams生成子View的MeasureSpec，并传给子View的measure(int widthMeasureSpec, int heightMeasureSpec) 方法让子View进行自身的测量。等所有的子View完成测量后，ViewGroup会根据自己的布局规则（测量规则）和子View的测量宽高完成自身的测量。

一、MeasureSpec：测量规则

想要了解测量流程我们需要先了解MeasureSpec类，MeasureSpec是View类的一个内部类。MeasureSpec的作用在于：在Measure流程中，系统会将View的LayoutParams根据父容器所施加的规则转换成对应的MeasureSpec，然后在onMeasure方法中根据这个MeasureSpec来确定View的测量宽高，view可以有自己的宽高要求，但我们要考虑MeasureSpec的规则。

我们查看MeasureSpec的源码：

public static class MeasureSpec {
    private static final int MODE_SHIFT = 30;
    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

    /** @hide */
    @IntDef({UNSPECIFIED, EXACTLY, AT_MOST})
    @Retention(RetentionPolicy.SOURCE)
    public @interface MeasureSpecMode {}

    public static final int UNSPECIFIED = 0 << MODE_SHIFT;


    public static final int EXACTLY     = 1 << MODE_SHIFT;


    public static final int AT_MOST     = 2 << MODE_SHIFT;

 
    public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                      @MeasureSpecMode int mode) {
        if (sUseBrokenMakeMeasureSpec) {
            return size + mode;
        } else {
            return (size & ~MODE_MASK) | (mode & MODE_MASK);
        }
    }
    @UnsupportedAppUsage
    public static int makeSafeMeasureSpec(int size, int mode) {
        if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
            return 0;
        }
        return makeMeasureSpec(size, mode);
    }

     @MeasureSpecMode
    public static int getMode(int measureSpec) {
        //noinspection ResourceType
        return (measureSpec & MODE_MASK);
    }


    public static int getSize(int measureSpec) {
        return (measureSpec & ~MODE_MASK);
    }

    static int adjust(int measureSpec, int delta) {
        final int mode = getMode(measureSpec);
        int size = getSize(measureSpec);
        if (mode == UNSPECIFIED) {
         
            return makeMeasureSpec(size, UNSPECIFIED);
        }
        size += delta;
        if (size < 0) {
            Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +
                    ") spec: " + toString(measureSpec) + " delta: " + delta);
            size = 0;
        }
        return makeMeasureSpec(size, mode);
    }


}

MeasureSpec是一个32位的int值，前2位是SpecMode，表示测量模式，后30位是SpecSize，表示在某种测量模式下的规格大小。MeasureSpec将SpecMode和SpecSize打包成一个int值来避免过多的对象内存分配，为了方便操作，其提供了打包的方法makeMeasureSpec，SpecMode和SpecSize也是一个int值，MeasureSpec也可以通过方法getMode和getSize得到原始的SpecMode和SpecSize。

SpecMode有三种值，如下所示。

  1. ) UNSPECIFIED
    父容器不对View有任何限制，要多大给多大，这种情况一般用于系统内部， 我们在开发过程中基本用不到。
  2. ）EXACTLY
    父容器已经检测出View所需要的精确大小，这个时候View的最终大小就是SpecSize所指定的值。它对应于LayoutParams中的match_parent和具体的数值这两种模式。
  3. ）AT_MOST
    父容器指定了一个可用大小即SpecSize，View的大小不能大于这个值，具体是什么值要看不同View的具体实现。它对应于LayoutParams中的wrap_content。

二、查看测量流程源码

2.1 查看ViewRootImpl的PerformTraveals()方法

DecorView是视图的顶级View，我们添加的布局文件是它的一个子布局，而ViewRootImpl则负责渲染视图，它调用了一个performTraveals方法使得ViewTree开始三大工作流程，然后使得View展现在我们面前。该方法会依次调用：
performMeasure、performLayout、performDraw 进行测量布局绘制三大流程。
我们摘取其中一部分performMeasure代码查看：


WindowManager.LayoutParams lp = mWindowAttributes;
int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
    if (mView == null) {
        return;
    }
    Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
    try {
        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_VIEW);
    }
}

根布局的MeasureSpec是怎么来的呢？是的，就是上面的getRootMeasureSpec，查看该方法。

private static int getRootMeasureSpec(int windowSize, int rootDimension) {
    int measureSpec;
    switch (rootDimension) {

    case ViewGroup.LayoutParams.MATCH_PARENT:
 
        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
        break;
    case ViewGroup.LayoutParams.WRAP_CONTENT:

        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
        break;
    default:
        measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
        break;
    }
    return measureSpec;
}

参数windowSize窗口大小，rootDimension就是根布局ViewGroup.LayoutParams，我们会使用这两个参数通过MeasureSpec.makeMeasureSpec构建一个根布局的MeasureSpec。

然后我们看到在performMeasure方法中，调用了根布局的measure(int widthMeasureSpec, int heightMeasureSpec) 方法。根布局是ViewGroup ，而ViewGroup是没有measure方法的，只有ViewGroup的父类View有measure（）方法。View的measure（）方法中会调用onMeasure(widthMeasureSpec, heightMeasureSpec);方法进行测量。
我们继续查看View类的默认onMeasure（）方法

2.2 View类的默认onMeasure（）方法

View类的默认onMeasure（）方法会进行默认的测量，测量结果是通过getDefaultSize（）方法获取的。

setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
        getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
        
public static int getDefaultSize(int size, int measureSpec) {
    int result = size;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    switch (specMode) {
    case MeasureSpec.UNSPECIFIED:
        result = size;
        break;
    case MeasureSpec.AT_MOST:
    case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result;
}

可以看到，即使测量模式是AT_MOST，也返回了测量大小，这就是为什么我们自定义View时如果没有重写onMeasure（）方法，设置自定义View是wrap_content，我们的组件会充满父布局的原因。
最后通过setMeasuredDimension方法存储我们测量的组件宽高。

根View 是FrameLayout，我们查看FrameLayout重写的onMeasure（）方法。

2.3 从FrameLayout的onMeasure（）方法了解自定义ViewGroup的测量行为

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int count = getChildCount();

    final boolean measureMatchParentChildren =
            MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
            MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
    mMatchParentChildren.clear();

    int maxHeight = 0;
    int maxWidth = 0;
    int childState = 0;

    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);
        if (mMeasureAllChildren || child.getVisibility() != GONE) {
            measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();
            maxWidth = Math.max(maxWidth,
                    child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
            maxHeight = Math.max(maxHeight,
                    child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
            childState = combineMeasuredStates(childState, child.getMeasuredState());
            if (measureMatchParentChildren) {
                if (lp.width == LayoutParams.MATCH_PARENT ||
                        lp.height == LayoutParams.MATCH_PARENT) {
                    mMatchParentChildren.add(child);
                }
            }
        }
    }

    // Account for padding too
    maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
    maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

    // Check against our minimum height and width
    maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
    maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

    // Check against our foreground's minimum height and width
    final Drawable drawable = getForeground();
    if (drawable != null) {
        maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
        maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
    }

    setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
            resolveSizeAndState(maxHeight, heightMeasureSpec,
                    childState << MEASURED_HEIGHT_STATE_SHIFT));

    count = mMatchParentChildren.size();
    if (count > 1) {
        for (int i = 0; i < count; i++) {
            final View child = mMatchParentChildren.get(i);
            final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

            final int childWidthMeasureSpec;
            if (lp.width == LayoutParams.MATCH_PARENT) {
                final int width = Math.max(0, getMeasuredWidth()
                        - getPaddingLeftWithForeground() - getPaddingRightWithForeground()
                        - lp.leftMargin - lp.rightMargin);
                childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
                        width, MeasureSpec.EXACTLY);
            } else {
                childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                        getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                        lp.leftMargin + lp.rightMargin,
                        lp.width);
            }

            final int childHeightMeasureSpec;
            if (lp.height == LayoutParams.MATCH_PARENT) {
                final int height = Math.max(0, getMeasuredHeight()
                        - getPaddingTopWithForeground() - getPaddingBottomWithForeground()
                        - lp.topMargin - lp.bottomMargin);
                childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                        height, MeasureSpec.EXACTLY);
            } else {
                childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
                        getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                        lp.topMargin + lp.bottomMargin,
                        lp.height);
            }

            child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
        }
    }
}

可以看到该方法先循环子View,调用ViewGroup类的measureChildWithMargins（）方法，对子View进行自身测量，在所有测量的子View中找到最大宽高，然后调用resolveSizeAndState处理后用setMeasuredDimension设置为自身的宽高，最后对MATCH_PARENT布局参数的子View进行重新测量。
这里我们不详细展开，有兴趣的可以自行查看，包括其他系统的布局组件，像LinearLayout、RelativeLayout等等，测量过程都会测量子View，然后按照自身的布局特点（布局规则）进行自身的测量。

我们主要看measureChildWithMargins（）方法，相同作用的还有measureChild（）方法，作用都是传入ViewGroup的测量规则和子View，调用getChildMeasureSpec 生成子View的测量规则。最后将生成的子View的测量规则传入child.measure（）方法方法，让子View进行自身的测量。区别在于measureChildWithMargins会考虑Margins的影响，而measureChild方法不会。

protected void measureChildWithMargins(View child,
        int parentWidthMeasureSpec, int widthUsed,
        int parentHeightMeasureSpec, int heightUsed) {
    final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                    + widthUsed, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
                    + heightUsed, lp.height);

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
protected void measureChild(View child, int parentWidthMeasureSpec,
        int parentHeightMeasureSpec) {
    final LayoutParams lp = child.getLayoutParams();

    final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
            mPaddingLeft + mPaddingRight, lp.width);
    final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
            mPaddingTop + mPaddingBottom, lp.height);

    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}

查看ViewGroup类的getChildMeasureSpec方法：通过父ViewGroup的测量规则和子View的布局参数，生成子View的测量规则，最后传递到子View的onMeasure()方法供自View进行自身大小的测量。
该方法展示的也就是网上流传最多的一张图片

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
    int specMode = MeasureSpec.getMode(spec);
    int specSize = MeasureSpec.getSize(spec);

    int size = Math.max(0, specSize - padding);

    int resultSize = 0;
    int resultMode = 0;

    switch (specMode) {

    case MeasureSpec.EXACTLY:
        if (childDimension >= 0) {
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
   
            resultSize = size;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
   
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;


    case MeasureSpec.AT_MOST:
        if (childDimension >= 0) {
    
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
 
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
   
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;


    case MeasureSpec.UNSPECIFIED:
        if (childDimension >= 0) {

            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
       
            resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
            resultMode = MeasureSpec.UNSPECIFIED;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
    
            resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
            resultMode = MeasureSpec.UNSPECIFIED;
        }
        break;
    }
 
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

经过上面的查看，我们验证了开头的结论，Android组件整个测量的基本流程还是非常清晰的。

月亮下的小草屋
关注
ANDROID自定义视图——onMeasure，MeasureSpec源码 流程 思路详解
大苞米的专栏
07-17 2万+
自定义视图详解。MeasureSpec，onMeasure，measureChildren等方法源码分析。
Android View原理解析之测量流程（measure）
CodingEnding的博客
09-23 1100
自定义View是Android进阶路线上必须攻克的难题，而在这之前就应该先对View的工作原理有一个系统的理解。本系列将分为4篇博客进行讲解，本文主要对View的测量流程(measure)进行讲解。
Android onMeasure方法介绍
ym19860303的专栏
02-05 815
onMeasure方法在控件的父元素正要放置它的子控件时调用.它会问一个问题，“你想要用多大地方啊？”，然后传入两个参数——widthMeasureSpec和heightMeasureSpec. 　　它们指明控件可获得的空间以及关于这个空间描述的元数据. 　　比返回一个结果要好的方法是你传递View的高度和宽度到setMeasuredDimension方法里. 　　接下来的代
onMeasure方法
fener10289的专栏
11-27 1177
onMeasure方法在控件的父元素正要放置它的子控件时调用.它会问一个问题，“你想要用多大地方啊？”，然后传入两个参数——widthMeasureSpec和heightMeasureSpec. 　　它们指明控件可获得的空间以及关于这个空间描述的元数据. 　　比返回一个结果要好的方法是你传递View的高度和宽度到setMeasuredDimension方法里. 　　接下来的代码片段给
Android View.onMeasure方法的理解
热门推荐
03-06 2万+
View在屏幕上显示出来要先经过measure（计算）和layout（布局）. 1、什么时候调用onMeasure方法？  当控件的父元素正要放置该控件时调用.父元素会问子控件一个问题，“你想要用多大地方啊？”，然后传入两个参数——widthMeasureSpec和heightMeasureSpec. 这两个参数指明控件可获得的空间以及关于这个空间描述的元数据. 更好的方法是你传递View
Android onMeasure
Zhang Phil
01-17 703
Android onMeasureimport android.content.Context; import android.support.annotation.Nullable; import android.util.AttributeSet; import android.view.View; public class MyView extends View { public
Android View 测量流程(Measure)全面解析
08-31
总的来说，Android View的测量流程是通过MeasureSpec来传递父View的尺寸要求，并在`onMeasure()`中根据这些要求计算出View的实际大小。这个过程对于理解如何自定义View以及优化UI性能至关重要。在实际开发中，掌握这...
Android View 绘制流程(Draw)全面解析
08-31
本文将深入解析Android View的绘制流程，特别是`Draw`阶段。在前几篇文章中，我们讨论了 DecorView、测量流程（Measure）和布局流程（Layout）。现在，我们将聚焦于决定View外观的绘制流程。 首先，绘制流程始于`...
Android View 布局流程(Layout)全面解析
08-31
本篇文章将深入解析Android View的布局流程，帮助开发者理解这一过程。 首先，我们回顾一下View的工作流程，它包括测量（Measure）、布局（Layout）和绘制（Draw）三个阶段。在上一篇文章中，我们详细探讨了测量...
Android-自定义控件之onMeasure浅谈
愛橙絮
08-29 315
最近在练习自定义控件，网上资料太散，自己就记录一下。非常感谢那些分享的人，最后会标注上链接。 自定义控件中三大关键方法: 老大 onMeasure 老二 onLayout 老三 onDraw Android 中一切显示控件皆继承至 View，而 onMeasure 则用于测量 View 的大小，只有先确定了大小，才能开始其他绘制的后续工作。 但是不了解就无法写自定义控件了么？或者说必须要去处理 o...
android自定义组件(七) onMeasure测量尺寸
03-27
博客在: http://blog.csdn.net/ethan_xue/article/details/7401163
Android的onMeasure方法
青春的光与影
02-03 1532
在Android开发中，当Android原生控件不能满足我们的需求的时候，就需要自定义View。View在屏幕上绘制出来先要经过measure（计算）和layout（布局）。   什么时候调用onMeasure方法？   当子View的父控件要放置该View的时候，父控件会传递两个参数给View——widthMeasureSpec和heightMeasureSpec。这两个参数是Vie
Android onMeasure详解
weixin_45558166的博客
01-18 3635
理解Android onMeasure方法什么是父控件和子控件何时测量测量流程MeasureSpec 静态内部类ViewGroup中三个测量子控件的方法onMeasure()方法 什么是父控件和子控件         父控件就是容纳子控件的控件(也就是我们常说的布局)也称作容器，常见的父控件有LinearLayout，RelativeLayout，FrameLayout，TableLayout，GridLayout; &nbs
Android中自定义View的MeasureSpec使用
zhlf91718的专栏
04-17 432
onMeasure传入的两个参数是由上一层控件传入的大小，有多种情况，重写该方法时需要对计算控件的实际大小，然后调用setMeasuredDimension(int, int)设置实际大小。 onMeasure传入的widthMeasureSpec和heightMeasureSpec不是一般的尺寸数值，而是将模式和尺寸组合在一起的数值。我们需要通过int mode = Measu
自定义控件详解（五）：onMeasure()、onLayout()
defukwanmcth26174的博客
04-06 624
前言： 　　自定义控件的三大方法： 测量： onMeasure()： 测量自己的大小，为正式布局提供建议 布局： onLayout(): 使用layout()函数对所有子控件布局 绘制： onDraw(): 根据布局的位置绘图 onDraw() 里面是绘制的操作，可以看下其他的文章，下面来了解onMeasure()和onLayout()方...
Android OnMeasure
zzcchunter的专栏
06-08 592
http://stackoverflow.com/questions/13099652/custom-rotating-of-an-image-view onMeasure() is your opportunity to tell Android how big you want your custom view to be dependent the layo
android Onmeasure
坚持，努力
05-10 496
笔记- - android中 Onmeasure方法会在绘图前，也就是Ondraw()方法调用前调用，也就是Onmea
Android View 测量源码深度解析：PerformTraversals与Measure流程
"本文将深入解析Android视图(View)的测量(Measure)流程，基于Android API 21的源代码进行分析。" 在Android应用开发中，View的显示过程包括测量(Measure)、布局(Layout)和绘制(Draw)三个主要步骤。`ViewRootImpl#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值