Android 自定义View - 助记词

已于 2022-08-22 17:02:35 修改
阅读量568 收藏
点赞数
分类专栏： 自定义view 文章标签： 助记词 自定义view
于 2018-10-31 15:29:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yihaiyangbaobao/article/details/83584939
版权

UI今天给了个需求，把乱序的单词拼成一句话，如下图：
在这里插入图片描述
在这里插入图片描述
本来计划是用RecyclerView写的，突然脑子抽了想用paint来画(写完就后悔了-.-)
先看一下完成后的效果
在这里插入图片描述

前期的思路是这样的：
1.测量每个单词的高度和宽度，计算出所有单词排列后的高*2，就是view 的高度
2.把文字写上去
在这里插入图片描述

在这里插入图片描述
哈哈，这个的确就是当时的想法，不要怂就是干~
那就来试试吧，话不多说，直接上代码：

public class HelpWordView extends View {

    private Context mContext;

    private int rx = 10, ry = 10;
    private int mWidth;
    private int mHeight;
    private float mOffsetX;//X轴偏移量
    private float mOffsetY;//Y轴偏移量
    private int mScreenWidth;

    private int mTextColor;//字体颜色
    private int mPlaceColor;//放置区背景颜色
    private int mSelectColor;//选择区背景颜色
    private float mTextSize;//字体大小
    private float mTextMarginLeft;//距离左边间隔
    private float mTextMarginTop;//距离上面间隔

    private ArrayList<Word> mData;
    private ArrayList<Word> mShuffleData;
    private ArrayList<RectF> mSelectRectF;
    private ArrayList<RectF> mPlaceRectF;
    private ArrayList<String> mPlaceData;

    private Paint mTextPaint;
    private Paint mShapePaint;
    private Paint mPlacePaint;
    private Paint mSelectPaint;
    private Paint mTextMeasurePaint;

    private onResultCallback mOnResultCallback;

    private static final String TAG = "HelpWordView";


    public HelpWordView(Context context) {
        super(context);
    }

    public HelpWordView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.HelpWordView);
        mTextSize = typedArray.getDimension(R.styleable.HelpWordView_text_size, 35f);
        mTextMarginLeft = typedArray.getDimension(R.styleable.HelpWordView_text_marginLeft, 50f);
        mTextMarginTop = typedArray.getDimension(R.styleable.HelpWordView_text_marginTop, 30f);
        mTextColor = typedArray.getColor(R.styleable.HelpWordView_text_color, Color.BLACK);
        mPlaceColor = typedArray.getColor(R.styleable.HelpWordView_place_background_color, Color.rgb(240, 240, 240));
        mSelectColor = typedArray.getColor(R.styleable.HelpWordView_select_background_color, Color.WHITE);
        typedArray.recycle();//回收
        init();
    }

    public ArrayList<Word> getData() {
        return mData;
    }

    public void setData(ArrayList<Word> mData) {
        this.mData = mData;
        this.mShuffleData = new ArrayList<>();
        this.mShuffleData.addAll(mData);
        Collections.shuffle(mShuffleData);
        invalidate();
    }

    public void setOnResultCallback(onResultCallback mOnResultCallback) {
        this.mOnResultCallback = mOnResultCallback;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        float tempWidth = 0;//存储宽度的临时变量
        float totalHeight = getTextHeight(mTextMeasurePaint) * 3;//view所占的屏幕高度
        if (null != mShuffleData) {
            for (Word word : mShuffleData) {
                tempWidth += getTextWidth(word.getWord(), mTextMeasurePaint) + mTextMarginLeft;//累加计算出当前文字的宽度
                if (tempWidth >= mScreenWidth) {//如果累加的宽度大于屏幕的宽度则换行
                    totalHeight += getTextHeight(mTextMeasurePaint) + mTextMarginTop;
                    tempWidth = getTextWidth(word.getWord(), mTextMeasurePaint) + mTextMarginLeft;
                }
            }
        }
        totalHeight += totalHeight;
        setMeasuredDimension(mScreenWidth, (int) totalHeight);
    }

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        mWidth = w;
        mHeight = h;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawPlace(canvas);
        drawSelect(canvas);
    }

    //画放置区的文字
    private void drawPlace(Canvas canvas) {
        mPlaceRectF = new ArrayList<>();
        RectF rectF = new RectF(0, 0, mWidth, mHeight / 2);
        canvas.drawRect(rectF, mPlacePaint);

        float startX = 0;
        float startY = getTextHeight(mTextMeasurePaint);
        float tempX = 0;

        for (String str : mPlaceData) {

            if (tempX + getTextWidth(str, mTextMeasurePaint) + mTextMarginLeft + mOffsetX >= mScreenWidth) {
                tempX = 0;
                startX = 0;
                startY += getTextHeight(mTextMeasurePaint) + mTextMarginTop;
            }

            tempX += getTextWidth(str, mTextMeasurePaint) + mTextMarginLeft;
            RectF position = new RectF(startX, startY - getTextHeight(mTextMeasurePaint), tempX - mTextMarginLeft, startY);
            mPlaceRectF.add(position);

            if (tempX >= mScreenWidth) {
                tempX = 0;
                startY += getTextHeight(mTextMeasurePaint) + mTextMarginTop;
            }
            startX = tempX;
        }

        ArrayList<ArrayList<RectF>> total = new ArrayList<>();
        ArrayList<RectF> temp = new ArrayList<>();
        for (int i = 0; i < mPlaceRectF.size(); i++) {
            if (i > 0) {
                if (mPlaceRectF.get(i).bottom == mPlaceRectF.get(i - 1).bottom) {
                    temp.add(mPlaceRectF.get(i));
                } else {
                    total.add(temp);
                    temp = new ArrayList<>();
                    temp.add(mPlaceRectF.get(i));
                }
            } else {
                temp.add(mPlaceRectF.get(i));
            }
        }
        if (temp.size() > 0) {
            total.add(temp);
        }

        if (total.size() > 0) {
            mPlaceRectF = new ArrayList<>();

            for (int i = 0; i < total.size(); i++) {
                for (RectF f : total.get(i)) {
                    f.offset(mOffsetX, mOffsetY);
                    mPlaceRectF.add(f);
                }
            }
        }

        for (int i = 0; i < mPlaceRectF.size(); i++) {
            float textWidth = getTextWidth(mPlaceData.get(i), mTextPaint);
            float textHeight = getTextHeight(mTextPaint);
            float textX = (float) (mPlaceRectF.get(i).left + textWidth);
            float textY = (float) (mPlaceRectF.get(i).bottom - textHeight / 2.0);
            canvas.drawRoundRect(mPlaceRectF.get(i), rx, ry, mSelectPaint);
            canvas.drawText(mPlaceData.get(i), textX, textY, mTextPaint);
            canvas.drawRoundRect(mPlaceRectF.get(i), rx, ry, mShapePaint);
        }

    }

    //画选择区的文字
    private void drawSelect(Canvas canvas) {
        mSelectRectF = new ArrayList<>();
        //画选择区的矩形
        RectF rectF = new RectF(0, mHeight / 2, mWidth, mHeight);
        canvas.drawRect(rectF, mSelectPaint);

        float startX = 0;
        float startY = getTextHeight(mTextMeasurePaint) + mHeight / 2;
        float tempX = 0;
        for (Word word : mShuffleData) {
            if (tempX + getTextWidth(word.getWord(), mTextMeasurePaint) + mTextMarginLeft >= mScreenWidth) {
                tempX = 0;
                startX = 0;
                startY += getTextHeight(mTextMeasurePaint) + mTextMarginTop;
            }

            tempX += getTextWidth(word.getWord(), mTextMeasurePaint) + mTextMarginLeft;

            RectF position = new RectF(startX, startY - getTextHeight(mTextMeasurePaint), tempX - mTextMarginLeft, startY);
            mSelectRectF.add(position);

            if (tempX >= mScreenWidth) {
                tempX = 0;
                startY += getTextHeight(mTextMeasurePaint) + mTextMarginTop;
            }
            startX = tempX;
        }

        ArrayList<ArrayList<RectF>> total = new ArrayList<>();
        ArrayList<RectF> temp = new ArrayList<>();
        for (int i = 0; i < mSelectRectF.size(); i++) {
            if (i > 0) {
                if (mSelectRectF.get(i).bottom == mSelectRectF.get(i - 1).bottom) {
                    temp.add(mSelectRectF.get(i));
                } else {
                    total.add(temp);
                    temp = new ArrayList<>();
                    temp.add(mSelectRectF.get(i));
                }
            } else {
                temp.add(mSelectRectF.get(i));
            }
        }

        if (temp.size() > 0) {
            total.add(temp);
        }

        if (total.size() > 0) {
            mSelectRectF = new ArrayList<>();
            float lastTop = total.get(total.size() - 1).get(total.get(total.size() - 1).size() - 1).top;
            float lastBottom = total.get(total.size() - 1).get(total.get(total.size() - 1).size() - 1).bottom;
            float freeY = mHeight - lastTop - (lastBottom - lastTop) / 2;

            int maxIndex = isBest(total);

            Log.e(TAG, "drawSelect: maxIndex = " + maxIndex);

            float freeX = mWidth - total.get(maxIndex).get(total.get(maxIndex).size() - 1).right;

            mOffsetX = (float) (freeX / (total.get(maxIndex).size() - 1.0));
            mOffsetY = (float) (freeY / (total.size() + 1 + 0.0));

            if (total.size() == 1) {
                mOffsetY = freeY / 3;
            }
            for (int i = 0; i < total.size(); i++) {

                for (RectF f : total.get(i)) {
                    f.offset(mOffsetX, mOffsetY);
                    mSelectRectF.add(f);
                }
            }
        }

        for (int i = 0; i < mSelectRectF.size(); i++) {
            if (!mShuffleData.get(i).isHide()) {
                float textWidth = getTextWidth(mShuffleData.get(i).getWord(), mTextPaint);
                float textHeight = getTextHeight(mTextPaint);
                float textX = (float) (mSelectRectF.get(i).left + textWidth);
                float textY = (float) (mSelectRectF.get(i).bottom - textHeight / 2.0);
                canvas.drawText(mShuffleData.get(i).getWord(), textX, textY, mTextPaint);
            }
            canvas.drawRoundRect(mSelectRectF.get(i), rx, ry, mShapePaint);
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                for (int i = 0; i < mSelectRectF.size(); i++) {
                    if (mSelectRectF.get(i).contains(event.getX(), event.getY())) {
                        if (!mShuffleData.get(i).isHide()) {
                            mPlaceData.add(mShuffleData.get(i).getWord());
                            mShuffleData.get(i).setHide(!mShuffleData.get(i).isHide());
                        }
                        invalidate();
                        break;
                    }
                }

                for (int i = 0; i < mPlaceRectF.size(); i++) {
                    if (mPlaceRectF.get(i).contains(event.getX(), event.getY())) {
                        setShow(mPlaceData.get(i));
                        mPlaceRectF.remove(i);
                        mPlaceData.remove(i);
                        invalidate();
                        break;
                    }
                }
                compare();
                break;
            case MotionEvent.ACTION_CANCEL:
                break;
            case MotionEvent.ACTION_UP:
                break;
        }
        return true;
    }

    private void init() {

        mScreenWidth = getScreenWidth();

        if (null == mTextPaint) {
            mTextPaint = new Paint();
            mTextPaint.setTextSize(mTextSize);
            mTextPaint.setAntiAlias(true);
            mTextPaint.setColor(mTextColor);
            mTextPaint.setTextAlign(Paint.Align.CENTER);
        }

        if (null == mTextMeasurePaint) {
            mTextMeasurePaint = new Paint();
            mTextMeasurePaint.setAntiAlias(true);
            mTextMeasurePaint.setTextSize((float) (mTextSize * 2));
            mTextMeasurePaint.setColor(mTextColor);
        }

        if (null == mPlacePaint) {
            mPlacePaint = new Paint();
            mPlacePaint.setColor(mPlaceColor);
            mPlacePaint.setAntiAlias(true);
            mPlacePaint.setStyle(Paint.Style.FILL);
        }

        if (null == mSelectPaint) {
            mSelectPaint = new Paint();
            mSelectPaint.setAntiAlias(true);
            mSelectPaint.setColor(mSelectColor);
            mSelectPaint.setStyle(Paint.Style.FILL);
        }

        if (null == mShapePaint) {
            mShapePaint = new Paint();
            mShapePaint.setAntiAlias(true);
            mShapePaint.setStyle(Paint.Style.STROKE);
            mShapePaint.setStrokeWidth(2);
            mShapePaint.setColor(Color.GRAY);
        }

        if (null == mSelectRectF) {
            mSelectRectF = new ArrayList<>();
        }

        if (null == mPlaceRectF) {
            mPlaceRectF = new ArrayList<>();
        }

        if (null == mPlaceData) {
            mPlaceData = new ArrayList<>();
        }
    }

    //比较用户选择的字符串顺序
    private void compare() {
        if (null == mData) {
            return;
        }
        if (null == mPlaceData) {
            return;
        }
        if (null != mOnResultCallback) {
            int count = 0;
            for (int i = 0; i < mPlaceData.size(); i++) {
                if (!mPlaceData.get(i).equals(mData.get(i).getWord())) {
                    count++;
                }
            }
            mOnResultCallback.error(count);
            if (mPlaceData.size() == mData.size()) {
                if (count == 0) {
                    mOnResultCallback.right();
                }
            }
        }
    }

    private int isBest(ArrayList<ArrayList<RectF>> lists) {

        ArrayList<Right> sortList = new ArrayList<>();

        for (int i = 0; i < lists.size(); i++) {
            sortList.add(new Right(i, lists.get(i).get(lists.get(i).size() - 1).right));
        }

        Collections.sort(sortList, new Comparator<Right>() {

            /**
             * 返回负数表示：o1 小于o2，
             * 返回0 表示：o1和o2相等，
             * 返回正数表示：o1大于o2*/
            @Override
            public int compare(Right o1, Right o2) {
                if (o1.value >= o2.value) {
                    return 1;
                }
                return -1;
            }
        });

        for (int i = sortList.size() - 1; i >= 0; i--) {
            ArrayList<RectF> rectFS = lists.get(sortList.get(i).index);
            if ((mWidth - rectFS.get(rectFS.size() - 1).right) / (rectFS.size() - 1.0) + rectFS.get(rectFS.size() - 1).right > mWidth) {
                continue;
            }
            return sortList.get(i).index;
        }
        return 0;
    }

    //显示字符串
    private void setShow(String text) {
        for (Word word : mShuffleData) {
            if (word.getWord().equals(text)) {
                word.setHide(!word.isHide());
            }
        }
    }

    //获取文字的高
    private int getTextHeight(Paint paint) {

        Rect rect = new Rect();
        paint.getTextBounds("测试", 0, "测试".length(), rect);
        return rect.height();
    }

    //获取文字的宽
    private float getTextWidth(String text, Paint paint) {
        return paint.measureText(text);
    }

    //获取屏幕的宽度
    private int getScreenWidth() {
        WindowManager windowManager = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics displayMetrics = new DisplayMetrics();
        windowManager.getDefaultDisplay().getMetrics(displayMetrics);
        return displayMetrics.widthPixels;
    }


    public interface onResultCallback {

        void right();

        void error(int count);
    }

    private class Right {
        int index;
        float value;

        public Right(int index, float value) {
            this.index = index;
            this.value = value;
        }
    }

    public static class Word {

        private String word;
        private boolean hide;

        public Word(String word) {
            this.word = word;
        }

        public Word(String word, boolean hide) {
            this.word = word;
            this.hide = hide;
        }

        public String getWord() {
            return word;
        }

        public void setWord(String word) {
            this.word = word;
        }

        public boolean isHide() {
            return hide;
        }

        public void setHide(boolean hide) {
            this.hide = hide;
        }
    }
}

在values新建一个attrs.xml文件

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <declare-styleable name="HelpWordView">

        <!--放置区的背景颜色-->
        <attr name="place_background_color" format="color" />
        <!--选择区的背景颜色-->
        <attr name="select_background_color" format="color" />
        <!--文字大小-->
        <attr name="text_size" format="dimension" />
        <!--距离左边间隔-->
        <attr name="text_marginLeft" format="dimension" />
        <!--距离上面间隔-->
        <attr name="text_marginTop" format="dimension" />
        <!--文字颜色-->
        <attr name="text_color" format="color" />

    </declare-styleable>

</resources>

在这里插入图片描述

对于这么简单的需求来说这个代码量稍微有点多~
唉写完了自己也看不懂了，里面有很多可以优化的地方，等有时间再来改改吧。

易保山
关注
专栏目录
Andorid自定义View学习Demo
07-20
Andorid自定义View学习Demo，包含常见的所有知识点，Layout, Paint,Xfermode,mask filter, canvas, reveal, search,path,path measure, svg, plus等
Android学习小demo（1）自定义View
xiaoheliushuiya
01-02 158
在Android的开发中，很多时候系统提供的View已经不能够满足我们的要求，自定义View的需求自然而然就出来了。 实现自定义的View，其实就是去扩展View类，重写其某些方法函数，把原来由Android Framework 实现的东西，让我们自己来实现自己想要的某些效果。 其本质上就是封装了一些自己想要的效果，并使之能够被Framework识别，跟普通的系统的控件一样，可以重复利用。 ...
Android：创建自定义View
最新发布
ChinaDragon10的博客
07-15 862
Android 框架中定义的所有视图类都会扩展 View。您的自定义视图还可以直接扩展 View，或者您可以通过扩展某个现有视图子类（如 Button）来节省时间。 如需允许 Android Studio 与视图交互，您必须至少提供一个接受 Context 和 AttributeSet 对象作为参数的构造函数。此构造函数允许布局编辑器创建和编辑视图的实例。
Android自定义View研究(一) -- 一个小Demo
wangyeqiang的专栏
05-04 542
Android中继承View(一) -- 一个小Demo 序：总想写下点东西出来，但是总是没有时间，不是业务忙就是又有新的研究项目，最近有点时间，写点以前一直想写有一直没写的东西，供大家参考，但是终归是一家之言，仅供参考。本人的每次讲解都会提供源代码下载，并且会最近会一直更新还请大家多多关注，有不对的地方欢迎指教。好了，不说题外话了，咱们开始研究。   一、         概述   对
Android 自定义View汇总,Demo
ThePromonkeyOf_HeLuo的博客
05-04 878
Demo 自定义动画酷炫的提交按钮 优酷星球头条-卡片式控件-自定义控件实现方式 - 知识 Android之自定义View的死亡三部曲之Layout 从0到1Android自定义View（四）贝塞尔曲线 自定义控件–给控件添加阴影效果与发光效果 Android自定义控件之从0到1轻松实现侧滑按钮 Android 贝塞尔曲线解析 Android View绘制的三大流程 自定义View入门及实战案例
[安卓开发] 自定义View之一: 组合View Demo
07-17
http://blog.csdn.net/niubitianping/article/details/51933523
Android 自定义view-仿新浪微博#话题#插入EditText
10-12
在Android开发中，自定义View是一项常见的需求，它允许开发者根据特定的设计要求创建独一无二的UI元素。本主题将深入探讨如何实现一个自定义View，即仿照新浪微博中的“#话题#”插入EditText的功能。这个功能使得...
Android 自定义View-实现快速索引-附件资源
03-02
Android 自定义View-实现快速索引-附件资源
Android自定义View-点赞动画效果View-Demo
03-20
Android自定义View-点赞动画效果View-Demo，点赞后，会有动画效果，绘制箭头。
android 自定义View--实现跑马灯效果
11-28
本来想免费提供,本来想免费提供,本来想免费提供, 选项最低是2分. 8分的那个太贵了.
Android 自定义 View - 四个构造函数
teletian的专栏
07-16 3566
View 的构造函数有四个： 1. `public View(Context context)` 2. `public View(Context context, @Nullable AttributeSet attrs)` 3. `public View(Context context, @Nullable AttributeSet attrs, int defStyleAttr)` 4. `public View(Context context, @Nullable AttributeSet attrs
Android自定义View之进度条Demo
10-23
Android自定义View之进度条Demo，Android自定义View之进度条Demo
bip39-chooser:手动选择一个Bip39助记词
05-06
问候！ 此工具可以生成一个安全的随机助记词短语，您可以随后对其进行个人修改。 您选择的个人单词将帮助您确保该短语确实是随机的。 此页面以编程方式计算最后一个单词，因此您将拥有一个有效的Bip39短语。 初始短语是从浏览器的安全随机数生成器生成的，此外，调整每个单词还会带来以下好处： 自己选择助记词短语有助于防止出现缺陷或恶意的随机数生成器（但您应检查此代码） 快速访问新的强大安全且易于键入的助记词 从冷藏创建或验证助记词短语 跑步 下载或克隆此存储库 运行npm install然后npm run build然后打开./bip39-chooser.html 概述 选择短语的大小（12，15，18，21，24） 从计算机生成的随机性强短语开始，调整任何或所有单词 最后一个词是计算机生成的，使您的短语成为有效的BIP-39助记词 随时回来查看任何BIP-39短语 每个单词都根据B
浅谈android官方文档中自定义view的demo
Beanvy的博客
04-16 1263
官方文档上有个不错自定义view的例子，仔细分析一下可以加深对动画、Scroller、 GestureDetector等以及自定义View的理解
android 开发 View _4_ 我的简单自定义ViewDemo
qq_37217804的博客
07-03 521
package com.example.lenovo.mydemo.myViewDemo; import android.content.Context; import android.content.res.TypedArray; import android.graphics.Canvas; import android.graphics.Color; import android.grap...
Android自定义View
cychyl的博客
09-04 178
Android自定义View之Paint(画笔) Android自定义View中绘制的方式是重写绘制方法，其中最常用的是onDraw()方法，而在onDraw()方法绘制的关键是Canvas.drawxxx()方法，drawxxx()方法中一个很重要的参数就是Paint(画笔)，Android为Paint提供了众多属性，接下来，本篇着重介绍Paint的相关用法以及属性介绍。 Paint的初...
自定义View Demo
weixin_33688840的博客
05-16 257
public class VerticalOffsetLayout extends ViewGroup { private static final int OFFSET = 100; private Paint mPaint; public VerticalOffsetLayout(Context context) { super(context); init(context,...
Android 自定义View小实例-实现绘制打折标签
黄林晴
12-18 5922
前言 许多商城APP都会有商品打折的需求，而为文字添加下划线直接设置style就可以完成，我们在这里说的如下图，也就是我们demo实现的效果图。 1. 选取自定义View的方法 我们都知道自定义View有多种方式，比如继承自View、ViewGroup或者继承自现有的View子类等，每种实现方式的不同我们所需要做的处理工作也不同，从图中可以看出包含两个TextView，所以我们这里选取继...
Android 自定义view 入门 案例
LlanyW的专栏
04-11 904
9.最后在新建一个页面：ThreeActivity, 并在AndroidManifest.xml，设置为启动页面。创建完成后，在xml添加自定义view：activity_three.xml。第一个是逻辑代码，第二个是布局，第三个是view需要使用的属性（通过这种方式创建属性，多次创建可能造成一些变量重复定义。8.更新自定义布局：sample_super_circle_view.xml。sample_super_circle_view.xml布局源码。3.输入自定义名称，选择开发语言。11.最后运行即可。
Android自定义Ultra-PullToRefresh下拉刷新头部
文章还提到了自定义Header View的实现步骤和下拉刷新过程中不同状态的图片设计。" 在Android开发中，下拉刷新是一个常见的功能，用于更新列表或网格视图的内容。Ultra-PullToRefresh是一个流行的开源库，它提供了...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值