android自定义view之汽车仪表盘增强版

最新推荐文章于 2024-05-14 09:50:38 发布
最新推荐文章于 2024-05-14 09:50:38 发布
阅读量5.2k 收藏 9
点赞数 2
分类专栏： Android

下面是改进后的效果图
这里写图片描述
原文链接：
http://blog.csdn.net/lxk_1993/article/details/51373269
绘图流程总结：
onLayout() 主要是组合排列一些包含的控件（通常是已有控件）进行布局，以及子view布局
onMeasure() 测绘，控件大小测量，子view测绘控件大小（viewGroup）
onDraw() 图形绘制，主要是对画布canvas，画笔paint ；图形绘制，这个会涉及许多API，许多绘图技巧：圆形的绘制，矩形绘制，刻度绘制，文字绘制，bitmap图形绘制，以及复杂的精密图形的绘制（一个摩托车的绘制需要很多小部件，就像PS，图形分层绘制的思想）
前两个都是对view本身或者子view进行整体处理，onDraw() 处理针对的对象是一个view的内容，是局部的处理
当然了如果你需要对自定义的view实现触摸响应，事件分发还需要实现onTouchEvent()
改进点：
1 仪表盘 速度speed字体调整，调大
2 加油启动时 仪表盘亮灯（检测speed处理速度刻度线颜色）
3 对运行速度检测，不同速度表盘文字颜色有不同的变化，用来警示用户是否超速。

SpeedControlView

public class SpeedControlView extends View implements Runnable {

    //画笔
    //mPaint：绘制刻度
    //textPaint 表盘所有文字画笔
    //speedAreaPaint 速度指针扫描弧
    private Paint mPaint, textPaint, speedAreaPaint;
    private Context mContext;
    //屏幕宽高
    private int screenWidth, screenHeight;
    //仪表盘圆的半径
    private float raduis, sRaduis;
    //圆心
    private int pointX, pointY;
    //文字的偏移量
    private float textScale;
    //速度指针变化的位置
    private float linePointerX, linePointerY;
    //速度
    private int speed;
    //速度范围的2个扇形外切矩形
    private RectF speedRectF, speedRectFInner;
    //速度控制模式  1 加速  2 减速  3 手刹
    private int type;
    // 速度文字 绘制的XY坐标
    private int baseX, baseY;
    //屏幕密度
    private float mDensityDpi;
    //设置速度控制模式
    public void setType(int type) {
        this.type = type;
    }
    //开始重绘
    private boolean start = true;

    public void setStart(boolean start) {
        this.start = start;
    }
    // 设置速度 并重绘视图
    public void setSpeed(int speed) {
        this.speed = speed;
        if(speed<120){
            textPaint.setColor(Color.WHITE);
        }
        else if (speed>=120&&speed<=210)
            textPaint.setColor(Color.YELLOW);
        else
            textPaint.setColor(Color.RED);
        //
        postInvalidate();
    }
    public SpeedControlView(Context context) {
        this(context, null);
    }
    public SpeedControlView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }
    public SpeedControlView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        //获取屏幕宽高
//        screenWidth = ((Activity) context).getWindowManager().getDefaultDisplay().getWidth();
//        screenHeight = ((Activity) context).getWindowManager().getDefaultDisplay().getHeight();
        //获取屏幕宽高 和 屏幕密度dpi
        DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        screenWidth = displayMetrics.widthPixels;
        screenHeight = displayMetrics.heightPixels;
        //像素密度相对于标准320的比例
        mDensityDpi = displayMetrics.densityDpi / 320;
        //开启硬件加速
        //setLayerType(View.LAYER_TYPE_HARDWARE, null);
        setLayerType(LAYER_TYPE_SOFTWARE, null);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        //设置抗锯齿
        mPaint.setAntiAlias(true);
        //设置画笔样式 实心圆
        mPaint.setStyle(Paint.Style.FILL);
        //设置空心线宽
        mPaint.setStrokeWidth(5 * mDensityDpi);
        //初始化  圆心左边 和 半径
        raduis = screenWidth / 3;
        //圆心位于中心点
        pointX = pointY = screenWidth / 2;
//        pointY = screenHeight / 4;
        //设置抗锯齿
        textPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        textPaint.setAntiAlias(true);
        //设置画笔颜色
        textPaint.setColor(Color.WHITE);
        // 获取字体并设置画笔字体
       // Typeface typeface = Typeface.createFromAsset(mContext.getAssets(), "kt.ttf");
        //为速度文字设置画笔风格
       // textPaint.setTypeface(typeface);
        //设置抗锯齿
        speedAreaPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        speedAreaPaint.setAntiAlias(true);
        //设置画笔样式
        speedAreaPaint.setStyle(Paint.Style.FILL);
        // 设置速度范围扇形的渐变颜色
        //public LinearGradient (float x0, float y0, float x1, float y1, int[] colors, float[] positions, Shader.TileMode tile);
        Shader mShader = new LinearGradient(pointX - raduis, pointY, pointX + raduis, pointY,
                new int[]{0xFF445EED, 0xFF072AE9, 0xFF0625CE}, null, Shader.TileMode.CLAMP);
        speedAreaPaint.setShader(mShader);
        // 初始化速度范围的2个扇形外切矩形
        speedRectF = new RectF(
                pointX - raduis + 10 * mDensityDpi,
                pointY - raduis + 10 * mDensityDpi,
                pointX + raduis - 10 * mDensityDpi,
                pointY + raduis - 10 * mDensityDpi);
        speedRectFInner = new RectF(
                pointX - raduis / 2,
                pointY - raduis / 2,
                pointX + raduis / 2,
                pointY + raduis / 2);
    }
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawColor(Color.BLACK);
        //绘制外层圆
        drawCicle(canvas);
        //绘制速度范围扇形区域
        speedAreaPaint.setColor(0x7E3F51B5);
        drawSpeedArea(canvas);
        //变换画笔颜色 绘制刻度
        mPaint.setColor(0xBF3F6AB5);
        drawScale(canvas);
        //变换画笔颜色 绘制速度标识文字
        textPaint.setTextSize(25 * mDensityDpi);
        mPaint.setColor(Color.WHITE);
        sRaduis = raduis - 50 * mDensityDpi;
        textScale = Math.abs(textPaint.descent() + textPaint.ascent()) / 2;
//        Log.e("textScale", textScale + "");
        for (int i = 0; i < 8; i++) {
            drawText(canvas, 30 * i);
        }
        //绘制中间文字内容
        drawCenter(canvas);

    }
    /**
     * 绘制外层圆
     */
    private void drawCicle(Canvas canvas) {
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(0xFF343434);
        canvas.drawCircle(pointX, pointY, raduis, mPaint);
        //外圈2个圆
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(0xBF3F6AB5);
        //设置空心线宽
        mPaint.setStrokeWidth(4 * mDensityDpi);
        canvas.drawCircle(pointX, pointY, raduis, mPaint);
        //设置空心线宽
        mPaint.setStrokeWidth(3 * mDensityDpi);
        canvas.drawCircle(pointX, pointY, raduis - 10 * mDensityDpi, mPaint);
        //内圈2个圆
        mPaint.setStrokeWidth(5 * mDensityDpi);
        mPaint.setColor(0xE73F51B5);
        canvas.drawCircle(pointX, pointY, raduis / 2, mPaint);
        mPaint.setColor(0x7E3F51B5);
        canvas.drawCircle(pointX, pointY, raduis / 2 + 5 * mDensityDpi, mPaint);
        mPaint.setStrokeWidth(3 * mDensityDpi);
    }
    /**
     * 绘制速度区域扇形
     */
    private void drawSpeedArea(Canvas canvas) {
        int degree;
        if (speed < 210) {
            degree = speed * 36 / 30;
        } else {
           // degree = speed * 36 / 30;
            //速度达到一定后表盘指针不变化
            degree = 210 * 36 / 30;
        }
        canvas.drawArc(speedRectF, 144, degree, true, speedAreaPaint);
        // TODO: 2016/5/12
        //不显示中间的内圈的扇形区域
        speedAreaPaint.setColor(0xFF343434);
        mPaint.setColor(0xFF343434);
        mPaint.setStyle(Paint.Style.FILL);
        canvas.drawArc(speedRectFInner, 144, degree, true, mPaint);
        mPaint.setStyle(Paint.Style.STROKE);
    }
    /**
     * 绘制刻度
     */
    //需要调整刻度线 在此重写，这里使用mPaint
    private void drawScale(Canvas canvas) {
        if (speed>0)
        mPaint.setColor(Color.GREEN);
        for (int i = 0; i < 60; i++) {
            if (i % 6 == 0) {
                canvas.drawLine(pointX - raduis + 10 * mDensityDpi, pointY, pointX - raduis + 50 * mDensityDpi, pointY, mPaint);
            } else {
                canvas.drawLine(pointX - raduis + 10 * mDensityDpi, pointY, pointX - raduis + 30 * mDensityDpi, pointY, mPaint);
            }
            canvas.rotate(6, pointX, pointY);
        }
    }
    /**
     * 绘制速度标识文字
     */
    // 这里是绘制速度文字，使用画笔textPaint
    private void drawText(Canvas canvas, int value) {
        String TEXT = String.valueOf(value);
        switch (value) {
            case 0:
                // 计算Baseline绘制的起点X轴坐标
                baseX = (int) (pointX - sRaduis * Math.cos(Math.PI / 5) + textPaint.measureText(TEXT) / 2 + textScale / 2);
                // 计算Baseline绘制的Y坐标
                baseY = (int) (pointY + sRaduis * Math.sin(Math.PI / 5) + textScale / 2);
                break;
            case 30:
                baseX = (int) (pointX - raduis + 50 * mDensityDpi + textPaint.measureText(TEXT) / 2);
                baseY = (int) (pointY + textScale);
                break;
            case 60:
                baseX = (int) (pointX - sRaduis * Math.cos(Math.PI / 5) + textScale);
                baseY = (int) (pointY - sRaduis * Math.sin(Math.PI / 5) + textScale * 2);
                break;
            case 90:
                baseX = (int) (pointX - sRaduis * Math.cos(2 * Math.PI / 5) - textScale / 2);
                baseY = (int) (pointY - sRaduis * Math.sin(2 * Math.PI / 5) + 2 * textScale);
                break;
            case 120:
                baseX = (int) (pointX + sRaduis * Math.sin(Math.PI / 10) - textPaint.measureText(TEXT) / 2);
                baseY = (int) (pointY - sRaduis * Math.cos(Math.PI / 10) + 2 * textScale);
                break;
            case 150:
                baseX = (int) (pointX + sRaduis * Math.cos(Math.PI / 5) - textPaint.measureText(TEXT) - textScale / 2);
                baseY = (int) (pointY - sRaduis * Math.sin(Math.PI / 5) + textScale * 2);
                break;
            case 180:
                baseX = (int) (pointX + sRaduis - textPaint.measureText(TEXT) - textScale / 2);
                baseY = (int) (pointY + textScale);
                break;
            case 210:
                baseX = (int) (pointX + sRaduis * Math.cos(Math.PI / 5) - textPaint.measureText(TEXT) - textScale / 2);
                baseY = (int) (pointY + sRaduis * Math.sin(Math.PI / 5) - textScale / 2);
                break;
        }
        canvas.drawText(TEXT, baseX, baseY, textPaint);
    }
    /**
     * 绘制中间文字内容
     */
    //这里是最里面实时的速度值，和速度单位的绘制，使用画笔textPaint
    //measureText() 获取速度文本的坐标位置
    private void drawCenter(Canvas canvas) {
        //速度
        textPaint.setTextSize(60 * mDensityDpi);
        float tw = textPaint.measureText(String.valueOf(speed));
        baseX = (int) (pointX - tw / 2);
        baseY = (int) (pointY + Math.abs(textPaint.descent() + textPaint.ascent()) / 4);
        canvas.drawText(String.valueOf(speed), baseX, baseY, textPaint);

        //单位
        textPaint.setTextSize(30 * mDensityDpi);
        tw = textPaint.measureText("Km/h");
        baseX = (int) (pointX - tw / 2);
        baseY = (int) (pointY + raduis / 4 + Math.abs(textPaint.descent() + textPaint.ascent()) / 4);
        canvas.drawText("Km/h", baseX, baseY, textPaint);
    }

    @Override
    public void run() {
        int speedChange;
        //view内部实现一个线程接口，view加载完成 开启线程，这个线程做无限循环，无限的改变绘图参数，并调用view.postInvalied 进行重绘
        //GameLoop  游戏循环模型，无限循环，不断检测用户动作，根据不同动作类型，
        while (start) {
            //循环检测信号量type  这个信号量来源于用户按键动作
            switch (type) {
                case 1://油门
                    speedChange = 2;
                    break;
                case 2://刹车
                    speedChange = -5;
                    break;
                case 3://手刹
                    speed = 0;
                    speedAreaPaint.setColor(0x7E3F51B5);
                    textPaint.setColor(Color.WHITE);
                default:
                    speedChange = -2;
                    break;
            }
            //速度改变模型
            speed += speedChange;

            if (speed < 1) {
                speed = 0;
            }
            try {
                Thread.sleep(50);
                //间接调用 postinvalid
                setSpeed(speed);
            } catch (InterruptedException e) {
                e.printStackTrace();
                break;
            }
        }
    }
}

activity处理部分

    speedControlView = (SpeedControlView) findViewById(R.id.speed_control);
    //实体化
    speedUp = (Button) findViewById(R.id.speed_up);
    speedDown = (Button) findViewById(R.id.speed_down);
    shutDown = (Button) findViewById(R.id.shut_down);

   //设置监听
        speedUp.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        //按下的时候加速
                        speedControlView.setType(1);
                        break;
                    case MotionEvent.ACTION_UP:
                        //松开做自然减速
                        speedControlView.setType(0);
                        break;
                }
                return true;
            }
        });
        speedDown.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        //按下的时候减速
                        speedControlView.setType(2);
                        break;
                    case MotionEvent.ACTION_UP:
                        //松开做自然减速
                        speedControlView.setType(0);
                        break;
                }
                return true;
            }
        });
        shutDown.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        //按下的时候拉手刹
                        speedControlView.setType(3);
                        break;
                    case MotionEvent.ACTION_UP:
                        //松开做自然减速
                        speedControlView.setType(0);
                        break;
                }
                return true;
            }
        });

    }

另外还要在activity的生命周期中添加处理，自定义view注销，速度初始化，状态清零
布局文件

<RelativeLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@android:color/white"
    xmlns:android="http://schemas.android.com/apk/res/android"
    >
<app.example.com.viewmeasure.view.SpeedControlView
    android:id="@+id/speed_control"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@android:color/white"/>
<Button
    android:id="@+id/speed_up"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="油门"
    android:layout_alignParentBottom="true"
    android:layout_alignParentEnd="true" />
    <Button
        android:id="@+id/speed_down"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="刹车"
        android:layout_alignParentBottom="true"
        android:layout_centerHorizontal="true" />
<Button
    android:id="@+id/shut_down"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="手刹"
    android:layout_alignBaseline="@+id/speed_down"
    android:layout_alignBottom="@+id/speed_down"
    android:layout_toStartOf="@+id/speed_down"
    android:layout_marginEnd="41dp" />
</RelativeLayout>

页面布局可以使用android studio提供的拖拽方案，可以快速布局

后期迭代想法

1 仪表盘 背景绘制，提供背景设置接口供用户调用
2 通过传感器，模拟汽车启动，加速，减速，刹车 来实现仪表盘状态的改变
3 当仪表盘检测到速度超过阀值，提示方案：语音，震动器
4 绘图性能优化

卒迹
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android的一款自定义的仪表盘控件
07-29
android一款仪表盘控件,测试可以安装。具体如何整合到你的应用，查看我的博客文章
Android自定义View实现渐变色仪表盘
08-26
主要为大家详细介绍了Android自定义View实现渐变色仪表盘，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
推荐一个神奇的Android仪表盘库：SpeedView
最新发布
gitblog_00010的博客
05-14 361
推荐一个神奇的Android仪表盘库：SpeedView 项目地址:https://gitcode.com/anastr/SpeedView 当你在寻找一种方式为你的Android应用添加引人注目的速度计或仪表盘时，SpeedView库可能是你的不二之选。这是一个强大且可高度定制的库，允许你在游戏和各种应用中创建动态的、真实感十足的速度表和仪表盘。 1、项目介绍 SpeedView是一个轻量级（仅...
无敌好用的框架
wuqingsen1的博客
04-13 682
1.ViewPager 指示器（下面是效果图）； 搜索关键词：MagicIndicator GitHub地址：https://github.com/hackware1993/MagicIndicator 2. 时间滚动选择器（下面是效果图）： 搜索关键词：PickerView GitHub地址：https://github.com/Bigkoo/Android-Pi...
android自定义速度仪表盘,Android自定义仪表盘View
weixin_42423852的博客
05-25 444
Android自定义仪表盘View，仿汽车速度仪、刻度盘等，可自定义多种模式，简单灵活 。本例子来自：https://github.com/woxingxiao/DashboardViewDemo本项目主要由DashboardView自定义实现的，其中指针旋转角度可以通过布局修改参数。如下android:id="@+id/dashboardView1"android:layout_width="w...
Android自定义View实现仪表盘
qq_41008818的博客
12-30 1233
Android自定义View实现仪表盘
物联网之Android开发3——自定义温度仪表盘
L·lemon·L的博客
04-08 5738
这里延用之前的模板，主要是在FrontFragment页面添加一个自定义的温度仪表盘用于显示温度。 先看效果图（原谅这尴尬的配色，这就是一个小demo）： 第一步：首先创建一个自定义View（TempDashboardView.java） 在TempDashboardView里先继承View类， 然后进行下面的操作： 第二步：获取画布中心值 在onMeasure中利用getMeasureWidth()和getMeasureHeight()来获取画布的中心值（注意：这里的中心值并不是屏.
Android自定义仪表盘
一个android开发者的博客
01-01 2064
android自定义view画仪表盘
Android仪表盘实现
07-21
Android 利用Canvas Bitmap Matrix 实现汽车方向盘的旋转，可以用来修改成你自己想要的风格的仪表盘
Android自定义View制作仪表盘界面
09-01
主要介绍了Android自定义View制作仪表盘界面的相关资料,首先需要自定义仪表盘的属性，在构造方法种获取自定义属性，本文介绍的非常详细，具有参考借鉴价值，需要的朋友可以参考下
Android 自定义View 仪表盘
01-25
本文将深入探讨如何创建一个自定义的“仪表盘”View，以实现一个美观且功能丰富的界面元素。我们将覆盖以下知识点： 1. **自定义View的基本结构**： 创建自定义View通常涉及继承现有View类，如`View`或`ViewGroup`...
android应用源码速度仪表盘.zip
12-04
Android 应用开发源码 参考与学习使用
在android实现仪表盘布局效果
04-28
在android实现仪表盘布局效果，这是google开源的-android dashboard
Android自定义控件实现方向盘效果
01-03
在很多开发中，为了界面更加的友好，在自定义View的基础上，开发者会开发出各种各样的自定义控件来满足实际开发需要，其中有一种”方向盘”的控件在实际开发中非常常见，便于用户进行一些实际性的方向控制。 在复习参考了许多自定义控件的基础上，我实现了一个最最基本的方向盘空间，并且可以根据方向做出相应的反应。话不多说，先看看效果。 做的有点丑，大家可以看看实际原理，后期再优化具体“方向盘”. 空间下面的几行字是我为了确定方向所写的一些参数，基本思想就是在方向盘的中心确定一个坐标轴，根据中间这个小圆的和中心点的距离与方向确定所处的方向。在手离开屏幕以后，小圆回到原点。 一言不合就放代码~~~~ 具体
Android自定义汽车仪表
06-21
本话题聚焦于"Android自定义汽车仪表"，这通常涉及到创建一个模仿真实汽车仪表盘的用户界面，包括速度表、转速表、油量指示器等元素。在Android应用中实现这样的功能，开发者需要深入理解Android图形绘制、动画和...
Android自定义view之仿支付宝芝麻信用仪表盘示例
01-20
自定义view练习 仿支付宝芝麻信用的仪表盘 对比图： 首先是自定义一些属性，可自己再添加，挺基础的，上代码 <?xml version=1.0 encoding=utf-8?> <!--最大数值--> <!--圆盘起始角度--&...
Android 自定义仪表盘
小小的博客
07-04 3565
最近需要写一个用到各种图表的项目，比较过后决定用hellocharts框架，感觉足够简洁，后来发现这框架里没有仪表盘这个控件，但又不想换其他框架，于是在网上搜索一番，找到一个仪表盘学习demo，尝试后初步改成了所需样式。
Android自定义控件之双刻度仪表盘实例
u011266964的博客
03-13 552
不多说，先上效果图： 软件开发环境：android studio3.2 + android 8.0 硬件环境：NXP(FRESSCALE) imx6q 直接点，上代码，有需要的去下载：
【视频文稿】车载Android应用开发与分析 - 走进车载操作系统
linkwj的博客
02-13 2419
根据Counterpoint Research的调研，2022年中国智能手机销量同比下降高达14%，达到了近十年来的最低水平...
android 自定义温度仪表盘
05-11
Android 自定义温度仪表盘是一种非常实用的 APP 设计，主要是为了满足用户对于实时温度的监测需求而开发的。通过该应用，用户可以直观地了解到当前室内温度的变化情况，同时还能够根据实际需要进行相关操作。 首先，实现一个自定义温度仪表盘的过程中，需要考虑到很多方面，比如说界面的设计、数据的获取和可视化等等。因此，需要运用到 Android 的相关知识和技巧，如 View 组件、Canvas 绘图、资源文件等等。在这个过程中，技术架构方面我们需要先确定该 APP 对于用户需求的具体响应方式，结合用户的操作反馈做出相应的设计。 其次，对于数据获取方面，可以结合第三方温度传感器进行数据的读取。通过该传感器不断地获取温度数据，我们可以观察到实时的温度变化情况，并且将这些数据储存在本地数据服务器内，方便之后的温度监控与统计。 最后，对于可视化方面，我们可以运用视觉化图表的技术，将收集到的数据进行展示。在设计温度仪表盘时，需要考虑到实用性和美观度的综合平衡，根据用户产品定位效果，我们可以运用 Android 的图形库，实现出富有设计感的数据可视化表现。 总的来说，对于 Android 自定义温度仪表盘的实现，需要结合多方面因素，包括技术架构、数据获取与存储、以及可视化等等。只有通过全面而细节的设计与开发工作，才能够创造出更加贴近用户需求，并且使用体验良好的 APP 产品。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值