【android 遥杆控件 自定义控件】

已于 2023-07-05 14:24:32 修改
阅读量203 收藏 1
点赞数
文章标签： android
于 2023-06-30 14:54:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37630270/article/details/131476762
版权

android 遥杆控件 自定义控件

遥杆控件 android 自定义控件

、
在这里插入图片描述

package com.sun.demo1;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.SystemClock;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import androidx.core.content.ContextCompat;



/**
 * Created by jaelyn on 16-06-29.
 * 摇杆view
 */
public class RockerView extends View {
    public static final int BACK_MODE_LINE_Y = 1;
    public static final int BACK_MODE_CENTER = 0;
    public static final int CONTROL_BY_TOUCH = 0;
    public static final int CONTROL_BY_ORIENTATION = 1;
    private static final int TOUCH_DOWN = 0;
    private static final int TOUCH_MOVE = 1;
    private static final int TOUCH_UP = 2;
    private static final int TOUCH_CENTER = 3;
    private static final float PagerMarginsScale = 0.0f;
    private Drawable mDrawBg;
    private Drawable mDrawRocker;
    private int mPagerMargins = 0;
    private int mBgWight;
    private int mBgR;
    private int mRockerWidth, mRockerR;
    private int mRockerX, mRockerY;
    private Rect mRockerRect = new Rect();
    private int mRockerGravide = 0;
    private int mRockeBackMode = BACK_MODE_LINE_Y;
    private int mTouchMode = TOUCH_CENTER;

    private Paint paint = new Paint();

    private OnLocaListener onLocaListener;

    private byte trimX = (byte) 128, trimY = (byte) 128;

    private SensorUtil sensorUtil;

    private int mControlMode = CONTROL_BY_TOUCH;

    private float mRockerXPer, mRockerYPer;
    private float angle;

    public String name;


    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public String avenue;
    public String spareAvenue;

    public String getAvenue() {
        return avenue;
    }

    public void setAvenue(String avenue) {
        this.avenue = avenue;
    }

    public String getSpareAvenue() {
        return spareAvenue;
    }

    public void setSpareAvenue(String spareAvenue) {
        this.spareAvenue = spareAvenue;
    }

    public OnMyMoveListener myMoveListener;
    public void setOnMyMoveListener(OnMyMoveListener listener){
        this.myMoveListener=listener;
    }


    RotationListener rotationListener;
    public interface RotationListener {
        // 角度
        void AngleChange(float angleNum);
        // 是否显示方向标
        void isShow(boolean isShow);
        // 方向值
        void PositionChange(int type, int x,int y);
        // 按下时的坐标
        void onDown(float x,float y);
    }
    public void setRotationListener(RotationListener rotationListener){
        this.rotationListener = rotationListener;
    }

    private Runnable moveBackRunnable = new Runnable() {
        @Override
        public void run() {
            moveBack();
        }
    };

    public RockerView(Context context) {
        super(context);
        init(null, 0);
    }

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

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

    public void init(AttributeSet attrs, int defStyleAttr) {
        paint.setColor(0xaaff0000);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
        int parentHeight = MeasureSpec.getSize(heightMeasureSpec);
        parentHeight = parentWidth = Math.min(parentWidth, parentHeight);
        mBgWight = parentWidth;
        mPagerMargins = (int) (parentWidth * PagerMarginsScale);
        mBgR = parentWidth / 2 - mPagerMargins - mRockerR;
        mRockerWidth = mDrawRocker.getIntrinsicWidth();
        mRockerWidth =(( mBgWight / 2) / 2) +10;
        mRockerR = mRockerWidth / 2;
        setMeasuredDimension(parentWidth, parentHeight);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        //绘制背景
        mDrawBg.setBounds(0, 0, mBgWight, mBgWight);
        mDrawBg.draw(canvas);
        //计算小球的位置
        mDrawRocker.setBounds(getRockerRect());
        //绘制小球
        mDrawRocker.draw(canvas);
    }

    /**
     * 以摇杆当前的坐标为中心点，计算Rocker绘画的范围
     * @return
     */
    private Rect getRockerRect() {
        int rockerX = (int) (mBgR * mRockerXPer + mBgWight / 2);
        int rockerY = (int) (-mBgR * mRockerYPer + mBgWight / 2);
        mRockerRect.set(rockerX - mRockerR, rockerY - mRockerR, rockerX + mRockerR,
                rockerY + mRockerR);
        return mRockerRect;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mControlMode == CONTROL_BY_ORIENTATION) {
            return super.onTouchEvent(event);
        }
        switch (event.getAction()) {
        case MotionEvent.ACTION_DOWN:
            if (isTouchRocker((int) event.getX(), (int) event.getY())) {
                mTouchMode = TOUCH_DOWN;
                if(rotationListener != null){
                    rotationListener.isShow(true);
                }
                return true;
            }
            break;
        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            if (mTouchMode == TOUCH_MOVE) {
                moveBack();
                mTouchMode = TOUCH_UP;
            }
            if(rotationListener != null){
                rotationListener.isShow(false);
            }
            break;
        }
        return super.onTouchEvent(event);
    }

    public boolean isTouchRocker(int x, int y) {
//        return mRockerRect.contains(x, y);
        return true;
    }

    private void moveRocker(float x, float y) {
        if (!isRange(x, y)) {
            setCircleXY(x, y);
        } else {
            mRockerX = (int) x;
            mRockerY = (int) y;
        }
        setLinstenerData();
        postInvalidate();
    }

    private boolean isRange(float x, float y) {
        float dx = mBgWight / 2 - x;
        float dy = mBgWight / 2 - y;
        return mBgR >= Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
    }

    private void setLinstenerData() {
        if (mBgR == 0) {
            return;
        }
        mRockerXPer = (mRockerX - mBgWight / 2f) / (float) mBgR;
        mRockerYPer = (mBgWight / 2f - mRockerY) / (float) mBgR;
        if(this.myMoveListener!=null){
            this.myMoveListener.onSignal(avenue, name, transformFB(mBgR, mRockerX - mBgWight / 2), 1);
            this.myMoveListener.onSignal(spareAvenue, name, transformFB(mBgR, mRockerY - mBgWight / 2), 2);
        }
    }

    public int transformFB(int radius, float num){
        int direction = 0;
        if(num > 0){
            direction = (int) ((Math.abs(num) / radius) * 90);
            direction = 90 + direction;
        }else if(num < 0){
            direction = (int) ((Math.abs(num) / radius) * 90);
            direction = 90 - direction;
        }else{
            direction = 90;
        }

        //超值锁
        if(direction > 180){
            direction = 180;
        }
        if(direction < 0){
            direction = 0;
        }
        return direction;
    }


    public interface OnLocaListener {
        void getLocation(int x, int y);
    }

    public void setOnLocaListener(OnLocaListener onLocaListener) {
        this.onLocaListener = onLocaListener;
    }

    private class AnimToBack implements Runnable {

        private long startTime;
        private float duration;
        private int startX, startY;
        private int dx, dy;

        public void start(int startX, int startY, int endX, int endY, int duration) {
            this.duration = duration;
            dx = endX - startX;
            dy = endY - startY;
            this.startX = startX;
            this.startY = startY;
            startTime = SystemClock.uptimeMillis();
            post(this);
        }

        @Override
        public void run() {
            float progress = (SystemClock.uptimeMillis() - startTime) / duration;
            if (progress >= 1) {
                progress = 1;
            } else {
                post(this);
            }
            moveRocker(dx * progress + startX, dy * progress + startY);
        }
    }

    private void setBackMode(int baceMode, boolean moveToBack) {
        this.mRockeBackMode = baceMode;
        if (moveToBack) {
            moveBack();
        }
    }

    public void moveBack() {
        int backX = mBgWight / 2;
        int backY = mBgWight / 2;
        if (mRockeBackMode == BACK_MODE_CENTER) {
            backY = backX = mBgWight / 2;
        } else if (mRockeBackMode == BACK_MODE_LINE_Y) {
            backX = mBgWight / 2;
            backY = mBgWight;
        }
        new AnimToBack().start(mRockerX, mRockerY, backX, backY, 150);
    }

    public void moveToPoint(float percentX, float percentY) {
        float x = percentX * mBgR + mBgWight / 2;
        float y = percentY * mBgR + mBgWight / 2;
        new AnimToBack().start((int) mRockerX, (int) mRockerY, (int) x, (int) y, 10);
    }

    public void moveToPointDura(float percentX, float percentY, int duration) {
        float x = percentX * mBgR + mBgWight / 2;
        float y = percentY * mBgR + mBgWight / 2;
        new AnimToBack().start((int) mRockerX, (int) mRockerY, (int) x, (int) y, 10);
        Handler handler = new Handler();
        handler.removeCallbacks(moveBackRunnable);
        handler.postDelayed(moveBackRunnable, duration);
    }

    public void setControlMode(int type) {
        final double stickyCenter = 0.09;
        if (type == CONTROL_BY_TOUCH) {
            mControlMode = CONTROL_BY_TOUCH;
            if (sensorUtil != null) {
                sensorUtil.unRegisterListener();
                sensorUtil = null;
            }
        } else if (type == CONTROL_BY_ORIENTATION) {
            mControlMode = CONTROL_BY_ORIENTATION;
            sensorUtil = new SensorUtil(getContext(), new SensorUtil.OnChangeListener() {
                @Override
                public void setXY(float dx, float dy) {
                    Log.d("sensor", dx + "--" + dy);
                    float x = dx * mBgR + (float) mBgWight / 2;
                    float y = dy * mBgR + (float) mBgWight / 2;
                    moveRocker(x, y);
                }
            });
            sensorUtil.registerListener();
        }
    }


    public float getAngle(float xx,float yy){
        double angle,k;
        if (mBgWight / 2==yy)//斜率不存在时
            if (mBgWight / 2 > xx)//判断x1指向x2的方向
                angle= -Math.PI/2;
            else
                angle= Math.PI/2;
        else{
            k=(mBgWight / 2-xx)/(mBgWight / 2-yy); //两点的坐标求斜率,至于为什么是(x1-x2)/(y1-y2)不是(y1-y2)/(x1-x2)待会我们再做解释
            if (mBgWight / 2 > yy) {//判断x1y1指向x2y2的方向
                // 用反tan求角度 这个高中好像没学过 既然Math类已经帮我们封装好了就直接拿来用吧
                angle = Math.atan(k) + Math.PI;
            } else {
                angle = Math.atan(k);
            }
        }
        return (float) angle;
    }

    /**
     * 角度值换算
     * @param num
     * @return
     */
    public  float transformAngle(float num){
        float  roundLength = (float) (Math.abs(num + 1.5) );
        num = (float) (roundLength / 0.0172);
        if(num > 360){
            num = 360;
        }else{
            num = 360 - num;
        }
        return num;
    }

    public void registerListener() {
        if (sensorUtil != null) {
            sensorUtil.registerListener();
        }
    }

    public void unregisterListener() {
        if (sensorUtil != null) {
            sensorUtil.unRegisterListener();
        }
    }

    public float getmRockerXPer() {
        return mRockerXPer;
    }

    public float getmRockerYPer() {
        return mRockerYPer;
    }

    public byte getTrimX() {
        return trimX;
    }

    public void setTrimX(byte trimX) {
        this.trimX = trimX;
    }

    public byte getTrimY() {
        return trimY;
    }

    public void setTrimY(byte trimY) {
        this.trimY = trimY;
    }
}

附 DEMO地址 https://download.csdn.net/download/qq_37630270/87971815

百思不得姐1
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Android自定义摇杆控件
10-21
在Android开发中，自定义控件是...总之，自定义Android摇杆控件需要掌握Android图形绘制、触摸事件处理以及自定义View的基本原理。通过以上步骤，我们可以创建一个美观且功能完备的摇杆控件，提升应用程序的交互体验。
Android虚拟摇杆
09-22
综上所述，Android虚拟摇杆的实现涉及自定义视图组件、图形绘制、触摸事件处理、坐标计算等多个方面。`JK-RockerView`可能就是一个完整的虚拟摇杆解决方案，包含了上述所有功能。在实际项目中，开发者可以根据需求对...
android studio游戏摇杆开发教程，仿王者荣耀摇杆
热门推荐
李子果 - 博客
06-16 150万+
最近在做一个山寨版的王者荣耀，刚开始做的时候毫无头绪 摇杆的多点触控做的特别烂 经过几天的思考已完美解决所有问题，下面就和大家分享下这个摇杆的开发思路（此教程不包含游戏源码） 若有不正之处，请多多谅解并欢迎指正。 首先这个摇杆要用到较多的数学知识，小编的数学特别烂也就高中水平吧 我们这个摇杆一共就五个按钮，一个移动摇杆、三个技能摇杆和一个普通攻击按钮 最终效果 ...
Android自定义摇杆
kongqw
09-01 2万+
转载请说明出处！ 作者：kqw攻城狮 出处：个人站 | CSDN效果图源码KqwRockerDemo喜欢就给个star，谢谢！功能 支持自适应大小 支持2个方向、4个方向、8个方向的摇动监听 支持摇动角度获取 可选回调模式 支持可摇动区域自定义 支持摇杆自定义 支持设置图片、色值、Share图形 使用<kong.qingwei.rockerlibrary.RockerView andro
2024年Android最全Android自定义摇杆(1)，2024年最新Android中高级面试必知必会
最新发布
2401_84563179的博客
05-14 550
开发是面向对象。我们找工作应该更多是面向面试。哪怕进大厂真的只是去宁螺丝，但你要进去得先学会面试的时候造飞机不是么？作者13年java转Android开发，在小厂待过，也去过华为，OPPO等，去年四月份进了阿里一直到现在。等大厂待过也面试过很多人。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含。
Android 自定义摇杆控件（使用图片）
cx415462822的专栏
10-21 3862
效果图 1.找两张图片  1）Joystick背景图片circle_1.png   2）Joystick图片circle_2.png   2.在layout中创建布局文件 imagejoystick.xml 内容为： &lt;?xml version="1.0"encoding="utf-8"?&gt; &lt;LinearLayout xmlns:android="h...
Android自定义view摇杆,Android自定义摇杆
weixin_29914581的博客
05-25 310
转载请说明出处！作者：kqw攻城狮出处：个人站 | CSDN效果图效果图效果图源码喜欢就给个star，谢谢！功能支持自适应大小支持2个方向、4个方向、8个方向的摇动监听支持摇动角度获取可选回调模式支持可摇动区域自定义支持摇杆自定义支持设置图片、色值、Shape图形使用android:id="@+id/rockerView_center"android:layout_width="100dp"and...
Android | 自定义摇杆控件
wangyu233的博客
05-24 2892
Android摇杆控件功能实现的监听功能方向模式用法准备工作八方向示例1).添加方向监听（方向发生改变触发）2).添加角度监听（角度发生改变触发）3).添加距离监听（距离发生改变触发）四方向示例1).添加方向监听（方向发生改变触发）2).添加角度监听，角度发生改变触发3).添加距离监听（距离发生改变触发）源代码 控件已开源，gitee项目地址:https://gitee.com/y141111/RockerView 先看实现的功能，如不能满足需求，不必浪费宝贵的时间继续看 功能 实现的监听功能 1.摇杆
android 手机端360度摇杆自定义
11-29
在Android开发中，实现一个360度的摇杆控件可以为用户提供更直观和灵活的游戏或应用控制体验。这个自定义摇杆的功能涉及到触摸事件处理、坐标转换以及动画效果等多个方面。以下将详细讲解如何在Android手机端实现...
自定义安卓摇杆源码
12-11
自定义摇杆源码,使用于AndroidUI的源码，属于java文件，配合自定义的layout文件使用。
【AndroidStudio】安卓虚拟摇杆组件
04-20
1.标准化的安卓页面虚拟摇杆 2.可获取虚拟摇杆的X、Y偏离值 3.横屏左右两个虚拟摇杆。 具体使用查看文章：https://blog.csdn.net/xanadw/article/details/124234671
Android代码-安卓虚拟摇杆
08-07
Rocker 一个安卓虚拟摇杆程序，可作为游戏控制器或者小车遥控器。 作者微博: @GcsSloop 摘要 由于需要制作一个控制小车移动的应用，使用按键控制不太舒服，故制作了一个虚拟摇杆。 之前的摇杆程序只是满足了基本功能，还有很多不方便以及不合理的地方，本次对其进行了重构，使其结构更佳合理，也完善了之前不足的部分。 目前已完成内容: 程序结构更佳合理 视图大小自适应 支持界面预览 支持在界面文件中直接配置参数 增加定时发送状态数据 基于 hello-earth 小伙伴的建议，分离了界面刷新周期和数据回调周期。 使用示例 默认参数 自定义参数 可自定义参数包括: 参数类型 中文 数据类型 默认值 简介 area_radius 区域半径 dimension 75dp 摇杆可活动区域的半径 rocker_radius 摇杆半径 dimension 25dp 摇杆本身半径 area_background 区域背景 color, reference CYAN 区域背景 rocker_background 摇杆背景 color, reference
【AndroidStudio】安卓虚拟摇杆组件demo
04-20
1.标准化的安卓页面虚拟摇杆的演示demo项目 2.横屏左右两个摇杆，并且可获取虚拟摇杆的X、Y偏离值 具体使用查看文章：https://blog.csdn.net/xanadw/article/details/124234671
android 开发之虚拟摇杆
11-19
android 虚拟摇杆，可用于游戏、遥控小车、四轴控制
android360摇杆
05-17
android360度游戏摇杆 改成 自定义控件
Android自定义摇杆实现蓝牙控制小车
05-17
1）控制摇杆由摇杆（小圆）和底座（大圆）组成； 2）全屏触摸，摇杆位置不离开底座范围； 3）停止触摸，摇杆恢复到中心，小车停止运动； 4）摇杆分成6个方向，分别控制小车 前进、后退、前进左、前进右、后退左、后退右。
二丶Android如何自定义一个可移动的飞行虚拟摇杆?
qq_29382709的博客
07-31 1635
事实上
自定义虚拟摇杆组件让你一劳永逸
测试开发小白变怪兽
09-04 1573
最近在研究虚拟摇杆实现方式的时候，发现网上的教程的实现方式可移植性并不是特别好，于是我决定自己实现一个虚拟摇杆组件，保存到自己的组件库，方便以后用到的时候直接使用（关注公众号后台回复「虚拟摇杆组件」可获取该组件），下面正文开始。 实现思路： 为了实现高度可移植，定义了两个节点属性，用于绑定场景和玩家角色，另外添加 PlayerNodeSpeed 属性和 MaxR 属性用于控制玩家移动速度和摇杆节点...
android自定义摇杆
05-18
Android 自定义摇杆可以通过继承 View 或者 ViewGroup 来实现。以下是一个简单的实现步骤： 1. 创建一个自定义 View 或者 ViewGroup，命名为 JoystickView。 2. 在 JoystickView 中定义一些必要的属性，例如大小、颜色、形状等。 3. 在 JoystickView 中重写 onMeasure() 方法，根据用户设置的大小来测量 View 的宽高。 4. 在 JoystickView 中重写 onDraw() 方法，绘制摇杆和底盘。 5. 在 JoystickView 中重写 onTouchEvent() 方法，处理用户触摸事件，计算出摇杆的位置并通知监听器。 6. 创建一个 JoystickListener 接口，并在 JoystickView 中定义一个 setJoystickListener() 方法，用于设置监听器。 7. 在 JoystickView 中实现回调接口，当摇杆位置发生变化时，通知监听器。 下面是一个简单的代码示例： ```java public class JoystickView extends View { private Paint paint; private int centerX; private int centerY; private int baseRadius; private int hatRadius; private JoystickListener joystickListener; public JoystickView(Context context) { super(context); init(); } public JoystickView(Context context, AttributeSet attrs) { super(context, attrs); init(); } public JoystickView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); init(); } private void init() { paint = new Paint(); paint.setAntiAlias(true); paint.setStyle(Paint.Style.FILL); } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { int width = MeasureSpec.getSize(widthMeasureSpec); int height = MeasureSpec.getSize(heightMeasureSpec); int size = Math.min(width, height); setMeasuredDimension(size, size); centerX = size / 2; centerY = size / 2; baseRadius = size / 3; hatRadius = size / 6; } @Override protected void onDraw(Canvas canvas) { // 绘制底盘 paint.setColor(Color.GRAY); canvas.drawCircle(centerX, centerY, baseRadius, paint); // 绘制摇杆 paint.setColor(Color.RED); canvas.drawCircle(centerX, centerY, hatRadius, paint); } @Override public boolean onTouchEvent(MotionEvent event) { float distance = (float) Math.sqrt(Math.pow(event.getX() - centerX, 2) + Math.pow(event.getY() - centerY, 2)); if (distance > baseRadius) { return true; } switch (event.getAction()) { case MotionEvent.ACTION_DOWN: case MotionEvent.ACTION_MOVE: float x = event.getX(); float y = event.getY(); invalidate(); if (joystickListener != null) { joystickListener.onJoystickMoved((x - centerX) / baseRadius, (y - centerY) / baseRadius); } break; case MotionEvent.ACTION_UP: invalidate(); if (joystickListener != null) { joystickListener.onJoystickReleased(); } break; } return true; } public void setJoystickListener(JoystickListener listener) { joystickListener = listener; } public interface JoystickListener { void onJoystickMoved(float xPercent, float yPercent); void onJoystickReleased(); } } ``` 使用示例： ```java public class MainActivity extends AppCompatActivity implements JoystickView.JoystickListener { private TextView directionTextView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); directionTextView = findViewById(R.id.direction_text_view); JoystickView joystickView = findViewById(R.id.joystick_view); joystickView.setJoystickListener(this); } @Override public void onJoystickMoved(float xPercent, float yPercent) { String direction = ""; if (xPercent < -0.5) { direction += "LEFT "; } else if (xPercent > 0.5) { direction += "RIGHT "; } if (yPercent < -0.5) { direction += "UP"; } else if (yPercent > 0.5) { direction += "DOWN"; } directionTextView.setText(direction); } @Override public void onJoystickReleased() { directionTextView.setText(""); } } ``` 以上示例中，我们在 MainActivity 中设置了一个 JoystickListener 监听器，当摇杆位置发生变化时，就会调用 onJoystickMoved() 方法。在 onJoystickMoved() 方法中，我们计算出摇杆的位置百分比，并根据百分比来判断摇杆的方向。最后将方向显示在 TextView 中。当用户松开摇杆时，我们会调用 onJoystickReleased() 方法，清空 TextView 中的内容。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

百思不得姐1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值