关于GAStudio哥玄酷的华为时钟界面代码学习

最新推荐文章于 2024-03-25 20:08:15 发布
最新推荐文章于 2024-03-25 20:08:15 发布
阅读量469 收藏
点赞数

package gastudio.clock.ui;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Xfermode;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;

import java.util.Calendar;

import gastudio.clock.R;
import gastudio.clock.utils.Constants;
import gastudio.clock.utils.UiUtils;

public class ClockViewByPath extends View {

private static final int DEFAULT_CLOCK_ANIMATION_DURATION = Constants.MINUTE;
private static final int FULL_ANGLE = 360;
private static final int SECOND_PER_MINUTE = 60;

private static final int DEFAULT_TOTAL_CLOCK_SCALE_LINE_NUM = 120;
private static final int DEFAULT_CLOCK_VIEW_WIDTH = 260;
private static final int ANGLE_PER_SECOND = FULL_ANGLE / SECOND_PER_MINUTE;
private static final int ANGLE_PER_SCALE = FULL_ANGLE / DEFAULT_TOTAL_CLOCK_SCALE_LINE_NUM;

private static final int DEFAULT_CLOCK_SCALE_LINE_COLOR = Color.WHITE;
private static final int DEFAULT_CLOCK_SCALE_LINE_WIDTH = 2;
private static final int DEFAULT_CLOCK_SCALE_LINE_HEIGHT = 14;
private static final int ADJUST_CLOCK_SCALE_LINE_START_X = 1;

private static final int DEFAULT_DIGITAL_TIME_TEXT_COLOR = Color.WHITE;
private static final int DEFAULT_DIGITAL_TIME_TEXT_SIZE = 60;
private static final String DEFAULT_DEFAULT_DIGITAL_TIME_TEXT = "00:00";

private static final int DEFAULT_CLOCK_POINT_COLOR = Color.RED;
private static final int DEFAULT_CLOCK_POINT_RADIUS = 6;

private static final float[] CLOCK_SCALE_LINE_BASE_LEN_ARRAY = new float[]{
        1F, 1.1F, 1.21F, 1.32F, 1.452F,
        1.551F, 1.6827F, 1.75F, 1.6827F, 1.551F,
        1.452F, 1.32F, 1.21F, 1.1F, 1F};
// This is max in CLOCK_SCALE_LINE_BASE_LEN_ARRAY
private static final float RATIO_OF_MAX_HEIGTH_TO_NORMAL_HEIGHT = 1.75F;

private int mClockScaleLineWidth;
private int mClockScaleLineHeight;
private int mClockScaleLineMaxHeight;
private int mClockScaleLineColor;
private int mAdjustClockScaleLineStartX;

private int mClockViewCenterX;
private int mClockViewCenterY;
private int mClockMaskRadius;
private RectF mClockViewRectF;
private Path mClockMaskPath;
private float mClockMaskAdjustAngle;

private int mClockPointRadius;
private int mClockPointColor;
private int mClockPointCenterX;
private int mClockPointCenterY;

private int mDigitalTimeTextStartX;
private int mDigitalTimeTextStartY;
private int mDigitalTimeTextSize;
private int mDigitalTimeTextColor;
private Rect mDigitalTimeTextRect;
private String mLastDigitalTimeStr;

private Paint mPaint;
private Xfermode mXfermode;
private ValueAnimator mClockAnimator;

private float mNowClockAngle;
private float mInitClockAngle;
private long mLastTimeMillis;
private Calendar mCalendar;

public ClockViewByPath(Context context) {
    this(context, null);
}

public ClockViewByPath(Context context, AttributeSet attrs) {
    this(context, attrs, 0);
}

public ClockViewByPath(Context context, AttributeSet attrs, int defStyleAttr) {
    this(context, attrs, defStyleAttr, 0);
}

public ClockViewByPath(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    TypedArray a = context.obtainStyledAttributes(
            attrs, R.styleable.ClockView);
    mDigitalTimeTextSize = a.getDimensionPixelSize(R.styleable.ClockView_timeTextSize,
            UiUtils.dipToPx(context, DEFAULT_DIGITAL_TIME_TEXT_SIZE));
    mDigitalTimeTextColor = a.getColor(R.styleable.ClockView_timeTextSize,
            DEFAULT_DIGITAL_TIME_TEXT_COLOR);
    mClockPointRadius = a.getDimensionPixelSize(R.styleable.ClockView_pointRadius,
            UiUtils.dipToPx(context, DEFAULT_CLOCK_POINT_RADIUS));
    mClockPointColor = a.getColor(R.styleable.ClockView_pointColor,
            DEFAULT_CLOCK_POINT_COLOR);
    mClockScaleLineWidth = a.getDimensionPixelSize(R.styleable.ClockView_timeScaleWidth,
            UiUtils.dipToPx(context, DEFAULT_CLOCK_SCALE_LINE_WIDTH));
    mClockScaleLineHeight = a.getDimensionPixelSize(R.styleable.ClockView_timeScaleHeight,
            UiUtils.dipToPx(context, DEFAULT_CLOCK_SCALE_LINE_HEIGHT));
    mClockScaleLineMaxHeight = (int) (RATIO_OF_MAX_HEIGTH_TO_NORMAL_HEIGHT * mClockScaleLineHeight);
    mClockScaleLineColor = a.getDimensionPixelSize(R.styleable.ClockView_timeScaleColor,
            UiUtils.dipToPx(context, DEFAULT_CLOCK_SCALE_LINE_COLOR));
    a.recycle();
    init();
}

@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
    super.onSizeChanged(w, h, oldw, oldh);
    int len = w > h ? h : w;
    mClockViewRectF.set(0, 0, len, len);
    mClockViewRectF.offset((w - len) / 2, (h - len) / 2);
    mClockViewCenterX = (int) mClockViewRectF.centerX();
    mClockViewCenterY = (int) mClockViewRectF.centerY();
    mDigitalTimeTextStartX = mClockViewCenterX - mDigitalTimeTextRect.left - mDigitalTimeTextRect.width() / 2;
    mDigitalTimeTextStartY = mClockViewCenterY - mDigitalTimeTextRect.top - mDigitalTimeTextRect.height() / 2;
    mClockPointCenterX = mClockViewCenterX;
    mClockPointCenterY = (int) (mClockViewRectF.top + mAdjustClockScaleLineStartX
            + mClockScaleLineMaxHeight + mClockPointRadius * 2);
    mClockMaskRadius = (int) (mClockViewRectF.width() / 2 - mClockScaleLineMaxHeight);
    generateMaskPath();
    mClockMaskAdjustAngle = (float) (CLOCK_SCALE_LINE_BASE_LEN_ARRAY.length + 1) / 2 * ANGLE_PER_SCALE;
}

private void generateMaskPath() {
    Log.i("zyl log 0223","generateMaskPath");
    Log.i("zyl log 0223","mClockViewCenterX = " + mClockViewCenterX);//260
    Log.i("zyl log 0223","mClockViewCenterY = " + mClockViewCenterY);//260
    Log.i("zyl log 0223","mClockViewCenterY - mClockMaskRadius - mClockScaleLineHeight = " + (mClockViewCenterY - mClockMaskRadius - mClockScaleLineHeight));
    Point point = new Point(mClockViewCenterX, mClockViewCenterY - mClockMaskRadius - mClockScaleLineHeight);//21
    mClockMaskPath.moveTo(point.x, point.y);

    // Generate contour of the special clock scale lines
    int arrayLen = CLOCK_SCALE_LINE_BASE_LEN_ARRAY.length;//15
    for (int index = 0; index < arrayLen; index++) {
        calculateNextPoint(point, CLOCK_SCALE_LINE_BASE_LEN_ARRAY[index],
                (float) Math.toRadians(ANGLE_PER_SCALE * (index + 1)));
         mClockMaskPath.lineTo(point.x, point.y);
    }

    // Generate contour of the normal clock scale lines
    int insertLen = mClockScaleLineMaxHeight - mClockScaleLineHeight;
    RectF cycleRectF = new RectF(mClockViewRectF);
    cycleRectF.inset(insertLen, insertLen);//03.10  ???
    //If dx is positive, then the sides are moved inwards, making the rectangle narrower
    mClockMaskPath.arcTo(cycleRectF, arrayLen * ANGLE_PER_SCALE - 90,//-45(对于圆心找-45度方位,与矩形交点即为划线起始点)
            (DEFAULT_TOTAL_CLOCK_SCALE_LINE_NUM - arrayLen) * ANGLE_PER_SCALE);//315,弧线划过的角度(相对于圆心)
}

private void calculateNextPoint(Point point, float scale, float angle) {
    Log.i("zyl log 0228","mClockMaskRadius = " + mClockMaskRadius);//211
    Log.i("zyl log 0228","mClockScaleLineHeight = " + mClockScaleLineHeight);//28
    float originLen = mClockMaskRadius + mClockScaleLineHeight;
    float adjustLen = mClockMaskRadius + mClockScaleLineHeight * scale;
    Log.i("zyl log 0228","mClockViewCenterX + (int) (adjustLen * Math.sin(angle) = " + (mClockViewCenterX + (int) (adjustLen * Math.sin(angle) ) ) ) ;
    Log.i("zyl log 0228","mClockViewCenterY - mClockMaskRadius - mClockScaleLineHeight\n" +
            "                        + (int) (-adjustLen * Math.cos(angle) + originLen) = " + (mClockViewCenterY - mClockMaskRadius - mClockScaleLineHeight
            + (int) (-adjustLen * Math.cos(angle) + originLen)));
    point.set(mClockViewCenterX + (int) (adjustLen * Math.sin(angle)),
            mClockViewCenterY - mClockMaskRadius - mClockScaleLineHeight
                    + (int) (-adjustLen * Math.cos(angle) + originLen));
}

private void init() {
    mClockViewRectF = new RectF();
    mDigitalTimeTextRect = new Rect();
    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setTextSize(mDigitalTimeTextSize);
    mPaint.getTextBounds(DEFAULT_DEFAULT_DIGITAL_TIME_TEXT, 0,
            DEFAULT_DEFAULT_DIGITAL_TIME_TEXT.length(), mDigitalTimeTextRect);
    mPaint.setStrokeWidth(mClockScaleLineWidth);
    mPaint.setStrokeCap(Paint.Cap.ROUND);
    mXfermode = new PorterDuffXfermode(PorterDuff.Mode.DST_OUT);//取下层绘制非交集部分(大小正方形中套圆)
    mAdjustClockScaleLineStartX = UiUtils.dipToPx(getContext(), ADJUST_CLOCK_SCALE_LINE_START_X);
    mClockMaskPath = new Path();
    mCalendar = Calendar.getInstance();
    mLastDigitalTimeStr = String.format("%02d:%02d", mCalendar.get(Calendar.HOUR),
            mCalendar.get(Calendar.MINUTE));
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
    int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
    if (widthSpecMode != MeasureSpec.EXACTLY) {
        widthMeasureSpec = MeasureSpec.makeMeasureSpec(
                UiUtils.dipToPx(getContext(), DEFAULT_CLOCK_VIEW_WIDTH), MeasureSpec.EXACTLY);
    }
    if (heightSpecMode != MeasureSpec.EXACTLY) {
        heightMeasureSpec = MeasureSpec.makeMeasureSpec(
                UiUtils.dipToPx(getContext(), DEFAULT_CLOCK_VIEW_WIDTH), MeasureSpec.EXACTLY);
    }
    setMeasuredDimension(widthMeasureSpec, heightMeasureSpec);
}

//03.08:
// 1.Canvas是一个很虚幻的概念，相当于一个透明图层（用过PS的同学应该都知道），每次Canvas画图时（即调用Draw系列函数），
// 都会产生一个透明图层，然后在这个图层上画图，画完之后覆盖在屏幕上显示
// 2.在画源图像时，会把之前画布上所有的内容都做为目标图像
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
// Save layer
//mPaint.setColor(Color.RED);
//canvas.drawRect(mClockViewRectF.left+10,mClockViewRectF.top+10,mClockViewRectF.right+10,mClockViewRectF.bottom+10,mPaint);
int layerOne = canvas.saveLayer(mClockViewRectF, mPaint, Canvas.ALL_SAVE_FLAG);
//03.08saveLayer会创建一个全新透明的bitmap，大小与指定保存的区域一致，其后的绘图操作都放在这个bitmap上进行。
// 在绘制结束后，会直接盖在上一层的Bitmap上显示
// Draw clock scale lines
mPaint.setColor(mClockScaleLineColor);
float clockScaleLineStartY = mAdjustClockScaleLineStartX + mClockViewRectF.top;
float clockScaleLineEndY = clockScaleLineStartY + mClockScaleLineMaxHeight;
for (int i = 0; i < 120; i++) {//120
Log.i(“zyl log 0309”,”clockScaleLineStartY = ” + clockScaleLineStartY);
Log.i(“zyl log 0309”,”clockScaleLineEndY = ” + clockScaleLineEndY);
canvas.drawLine(mClockViewCenterX, clockScaleLineStartY,
mClockViewCenterX, clockScaleLineEndY, mPaint);
canvas.rotate(ANGLE_PER_SCALE, mClockViewCenterX, mClockViewCenterY);//3度;其实是画布所在的坐标系的旋转
}
//2017.03.03 canvas.rotate方法会将坐标轴旋转!!!!
mPaint.setXfermode(mXfermode);
canvas.rotate(mNowClockAngle - mClockMaskAdjustAngle, mClockViewCenterX, mClockViewCenterY);
// Generate a mask by path
int layerTwo = canvas.saveLayer(mClockViewRectF, mPaint, Canvas.ALL_SAVE_FLAG);
Log.i(“zyl log 02281”,”mClockViewRectF = ” + mClockViewRectF);//(0,0,520,520)
Xfermode zXfermode = new PorterDuffXfermode(PorterDuff.Mode.SRC); //add by zyl 2017.03.09
//mPaint.setXfermode(null);
mPaint.setXfermode(zXfermode);
//为什么需要重置一下呢?
//1.因为在调用saveLayer时，会生成了一个全新的bitmap，这个bitmap的大小就是我们指定的保存区域的大小，
// 新生成的bitmap是全透明的，注意是透明的在调用saveLayer后所有的绘图操作都是在这个bitmap上进行的
//2.在layerOne时,Paint的Xfermode为取下层绘制非交集部分，那么在drawOval和drawPath之后效果跟新建一张透明图层效果是一样的
canvas.drawOval(mClockViewRectF, mPaint);//外层大圆
//mPaint.setXfermode(mXfermode);//取下层绘制非交集部分
zXfermode = new PorterDuffXfermode(PorterDuff.Mode.SRC_OUT);//03.09 ??? 为什么缺省一块？
mPaint.setXfermode(zXfermode);
//mPaint.setColor(mClockPointColor);
canvas.drawPath(mClockMaskPath, mPaint);//mClockMaskPath==眼球
//03.09:关于mClockMaskPath路径的计算???
canvas.restoreToCount(layerTwo);

    mPaint.setXfermode(null);
    // Draw clock point
    mPaint.setColor(mClockPointColor);
    canvas.rotate(mClockMaskAdjustAngle, mClockViewCenterX, mClockViewCenterY);
    canvas.drawCircle(mClockPointCenterX, mClockPointCenterY, mClockPointRadius, mPaint);

    canvas.restoreToCount(layerOne);
    updateTimeText(canvas);
}

private void updateTimeText(Canvas canvas) {
    long currentTimeMillis = System.currentTimeMillis();
    if (currentTimeMillis - mLastTimeMillis >= Constants.MINUTE) {
        mLastTimeMillis = currentTimeMillis;
        mCalendar.setTimeInMillis(currentTimeMillis);
        mLastDigitalTimeStr = String.format("%02d:%02d",
                mCalendar.get(Calendar.HOUR), mCalendar.get(Calendar.MINUTE));
    }
    mPaint.setColor(mDigitalTimeTextColor);
    canvas.drawText(mLastDigitalTimeStr, mDigitalTimeTextStartX, mDigitalTimeTextStartY, mPaint);
}

public void performAnimation() {
    cancelAnimation();
    mClockAnimator = ValueAnimator.ofFloat(0, FULL_ANGLE);
    mClockAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            mNowClockAngle = (float) animation.getAnimatedValue();
            mNowClockAngle += mInitClockAngle;
            invalidate();
        }
    });
    mClockAnimator.setDuration(DEFAULT_CLOCK_ANIMATION_DURATION);
    mClockAnimator.setInterpolator(new LinearInterpolator());
    mClockAnimator.setRepeatCount(Animation.INFINITE);
    mClockAnimator.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationStart(Animator animation) {
            super.onAnimationStart(animation);
            long currentTimeMillis = System.currentTimeMillis();
            mCalendar.setTimeInMillis(currentTimeMillis);
            mLastDigitalTimeStr = String.format("%02d:%02d", mCalendar.get(Calendar.HOUR),
                    mCalendar.get(Calendar.MINUTE));
            mInitClockAngle = (mCalendar.get(Calendar.SECOND)
                    + (float) mCalendar.get(Calendar.MILLISECOND) / Constants.SECOND) * ANGLE_PER_SECOND;
            mLastTimeMillis = currentTimeMillis - mCalendar.get(Calendar.SECOND) * Constants.SECOND
                    - mCalendar.get(Calendar.MILLISECOND);
        }
    });
    mClockAnimator.start();
}

public void cancelAnimation() {
    if (mClockAnimator != null) {
        mClockAnimator.removeAllUpdateListeners();
        mClockAnimator.removeAllListeners();
        mClockAnimator.cancel();
        mClockAnimator = null;
    }
}

}

Forever_lobster
关注
2023华为OD面试手撕代码经验分享
MISAYAONE的博客
05-17 2万+
华为OD 面试手撕代码经验分享
2024华为OD面试手撕代码真题目录
热门推荐
MISAYAONE的博客
04-28 5万+
一般面试的时候每一轮技术面都会出一到两个手撕代码题，这些题的特点就是，非常短小，易于理解。不可能会再出阅读理解一样的机试题的。但是这些题目也非常注意基本功，很注意细节的处理，一般都是easy+medium题目。但是大家一定要注意，因为大部分面试官上面一开始就会让你做题，直接看你所有的做题过程（防止有人水平一般，机试就网上找的答案的蒙混过关），手撕代码题会给你后面的面试定一个基调。
华为荣耀上一个小有意思的时钟效果
GAStudio
12-01 5833
今天主要给大家带来一个在荣耀8上看到的一个小有意思的时钟效果，这个效果比较简单，俗话说，“人生在世，无非就是把复杂的事情整简单，抑或把简单的事情搞复杂”，既然比较简单，那咱们就多用几种方案来实现，进而开拓一下思路； 首先先上效果图： 从效果图上看，和常见表盘一样，每根线代表一条时间刻度，一个红色小圈随着时间的变化不断的移动，而差异的点主要在于表盘有一个突起，并且这个突起随着红点
【Android Studio代码】数字时钟
09-02
用Android Studio 2.3.3做的数字时钟例子，主要用到的代码有：mTextView_Time = (TextView)findViewById(R.id.TextView_Time);、 mRunnable = new Runnable()、public void handleMessage(Message message)、new Thread(mRunnable).start();。
华为原生时钟
12-01
华为C8650+ 原生时钟 设置闹铃用
Android 钟表的实现
魏小魏
06-19 674
Android模拟时钟 Android数字时钟 Android时钟类控件实例
外形类似华为时钟的定时器控件
未来很长，但我会努力的走下去。
10-19 906
外形类似华为时钟的定时器控件
2023华为OD 面试手撕代码真题【LRU实现】
MISAYAONE的博客
06-12 4020
华为OD 面试手撕代码真题【LRU实现】
2024华为OD统一考试题库清单（持续收录中）以及考点说明
学Java，找哪吒
07-14 4万+
每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。
2023华为OD 面试手撕代码真题【求素数个数】
MISAYAONE的博客
06-08 4806
华为OD 面试手撕代码真题【求素数个数】
15款canvas时钟特效代码
06-12
15款基于canvas时钟特效是一款通过配置参数来生成15种不同外观的网页时钟。
桌面时钟（可以自定义透明度、背景颜色）
03-26
一款可以自定义透明度、背景颜色。支持开机启动，最低支持XP系统（需要安装.net framework4.0环境）。其他请下载使用体验，1分超值（幸苦分）。体验的好的话给个好评
android studio tabhost基础 多功能时钟app 实现时钟功能
sdsfs443的博客
07-23 1216
第一步： 新建timeview class，extends linearlayout： public class TimeView extends LinearLayout { private TextView textView; public TimeView(Context context, AttributeSet attrs) { super(con
关于GAStudio哥玄酷的下载动画中代码一些个人的学习
Forever_lobster的博客
04-02 354
package com.gastudio.gadownloading.ui; import android.animation.Animator; import android.animation.AnimatorListenerAdapter; import android.animation.AnimatorSet; import android.animation.ValueAnim...
鸿蒙开发组件（第二部分）
最新发布
l10711097061的博客
03-25 1059
是Text的子类，所以可以使用Text的一些属性。
《Android自定义控件》时钟、钟表AlarmClockView，仿华为手机世界时钟控件效果
陈少华的博客
01-04 2809
转载请标明出处：https://blog.csdn.net/m0_38074457/article/details/85790550，本文出自【陈少华的博客】 一、效果图 二、控件结构  三、代码实现 1、attrs.xml中添加自定义控件的属性 &lt;declare-styleable name="AlarmClockView"&gt; &lt;!--...
实现一个仿华为天气的进度圆
Void_J的博客
01-04 1163
第一次自己动手写东西，觉得写一遍能加深自己的理解，记忆，这个控件是基于别人的基础上改动的 ，原文连接 在这里！ 第一次弄，不会效果图，大概就是一个刻度盘 先说思路：每一个刻度是一条线条，根据圆心和半径来确定每条线的x,y终点坐标,以及根据圆心和(半径-短线长度)来确定每条线的x,y起点坐标，然后起点到终点画线就可以了。按圆弧的坐标画一百条线条表示刻度盘地盘 再换一个颜色的画笔画上进度
Android之模拟时钟和数字时钟，计时器
重心开始，重新开始
06-29 5375
1.AnalogClock和DigitalClock模拟时钟和数字时钟` <AnalogClock android:layout_width="wrap_content" android:layout_height="wrap_content"/> <DigitalClock android:layout_width="wrap_content" android:l
HTML时钟源码
欢迎来到 HsienChin 的博客
02-05 9846
动态时钟 body,div,p{ font-family: 'Microsoft Yahei' ;font-size: 14px;} .box{ width: 400px; height: 400px; border:10px solid #8bf2f1;margin:100px auto; border-radius: 50%; box-shadow
华为内部代码规范提升代码质量的关键要素
华为内部代码规范是一套详细的指导原则，旨在提升代码质量和组织性，确保团队间的协作效率。该规范涵盖多个关键领域，如排版、注释、标识符命名、可读性、变量与结构、函数与过程、可测性、程序效率、质量保证、代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值