学习笔记_基于Kotlin的蓝牙通信工具类

最新推荐文章于 2024-06-01 09:59:39 发布
最新推荐文章于 2024-06-01 09:59:39 发布
阅读量2.8k 收藏 15
点赞数 2
分类专栏： 学习笔记 文章标签： Kotlin 蓝牙 蓝牙通信 Kotlin工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TomCat0916/article/details/80408691
版权

学习笔记__基于Kotlin的蓝牙通信工具类

文章目录

使用Kotlin简单实现蓝牙通信,不是很稳定

蓝牙通信步骤

  • 获取蓝牙适配器
方法一:
BluetoothAdapter.getDefaultAdapter()

方法二:
val mBluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
 if (mBluetoothManager != null)
            mBluetoothAdapter = mBluetoothManager.adapter //获取蓝牙适配器
  • 检查蓝牙是否可用
 if (BluetoothUtils.getBluetoothAdapter(context) == null)
            return false
        return BluetoothUtils.getBluetoothAdapter(context).isEnabled
  • 打开/关闭蓝牙
打开蓝牙:
BluetoothUtils.getBluetoothAdapter(context).enable()
        val enable = Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE)
        enable.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, time)//设置可见时间
        context.startActivity(enable)
关闭蓝牙:
BluetoothUtils.getBluetoothAdapter(context).disable()
  • 搜索附近可见蓝牙

需要提前注册广播监听 BluetoothDevice.ACTION_FOUND

BluetoothUtils.getBluetoothAdapter(context).startDiscovery()
  • 停止搜索
BluetoothUtils.getBluetoothAdapter(context).cancelDiscovery()
  • 配对蓝牙
 btDevice.createBond()//btDevice为目标蓝牙设备对象
  • 建立服务器/客户端,并尝试连接

注意提前关闭搜索蓝牙,否则会影响连接稳定

  • 发起通信,接收信息

基于Kotlin的蓝牙通信工具类

工具类中Bonde类参考自网络,通过反射获取系统蓝牙相关操作方法

package com.cai.bluetoothtest.utils

import android.annotation.TargetApi
import android.app.Activity
import android.bluetooth.*
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.os.Build
import android.os.Handler
import android.os.Message
import android.os.ParcelUuid
import android.util.Log
import android.widget.Toast
import org.greenrobot.eventbus.EventBus
import java.io.IOException
import java.io.InputStream
import java.lang.reflect.Field
import java.lang.reflect.InvocationTargetException
import java.util.*


/*
 *  @项目名：  BluetoothTest 
 *  @创建者:   cai
 *  @创建时间:  2018/5/22 13:08
 *  @描述：    TODO
 */
object BluetoothUtils {


    private var mSocket: BluetoothSocket? = null
    private var mReadThread: ReadThread? = null
    private var mServerSocket: BluetoothServerSocket? = null
    private var mClientThread: ClientThread? = null
    private var mServerThread: ServerThread? = null

    const val HANDLER_RECEIVE_MESSAGE = 101

    /**
     * 获取蓝牙适配器
     */
    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
    fun getBluetoothAdapter(context: Context): BluetoothAdapter {
        var mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter()

        val mBluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager//获取蓝牙管理器
        if (mBluetoothManager != null)
            mBluetoothAdapter = mBluetoothManager.adapter //获取蓝牙适配器

        return mBluetoothAdapter
    }

    /**
     * 检查蓝牙是否打开(是否可用)
     */
    fun checkBleDevice(context: Context): Boolean {
        if (BluetoothUtils.getBluetoothAdapter(context) == null)
            return false
        return BluetoothUtils.getBluetoothAdapter(context).isEnabled
    }

    /**
     * 尝试打开蓝牙
     */
    fun openBluetooth(context: Context) {
        openBluetooth(context, 3600)//3600为蓝牙设备可见时间
    }

    /**
     * 尝试打开蓝牙
     */
    fun openBluetooth(context: Context, time: Int) {
        BluetoothUtils.getBluetoothAdapter(context).enable()
        val enable = Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE)
        enable.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, time)
        context.startActivity(enable)
    }

    /**
     * 关闭蓝牙
     */
    fun closeBluetooth(context: Context) {
        BluetoothUtils.getBluetoothAdapter(context).disable()
    }

    /**
     * 尝试搜索可见蓝牙设备
     */
    fun searchBluetooth(context: Context): Boolean {
        //如果当前发现了新的设备，则停止继续扫描，当前扫描到的新设备会通过广播推向新的逻辑
        if (BluetoothUtils.getBluetoothAdapter(context).isDiscovering()) {
            stopSearthBltDevice(context)
            return false
        }
        return BluetoothUtils.getBluetoothAdapter(context).startDiscovery()
    }

    /**
     * 尝试停止搜索
     */
    fun stopSearthBltDevice(context: Context): Boolean {
        return BluetoothUtils.getBluetoothAdapter(context).cancelDiscovery()
    }

    /**
     * 注册蓝牙广播
     */
    fun registerBluetoothReceiver(activity: Activity, receiver: BroadcastReceiver) {
        val intent = IntentFilter()
        intent.addAction(BluetoothDevice.ACTION_FOUND)//搜索发现设备
        intent.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED)//状态改变
        intent.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED)//行动扫描模式改变了
        intent.addAction(BluetoothAdapter.ACTION_STATE_CHANGED)//动作状态发生了变化
        intent.addAction(BluetoothDevice.ACTION_PAIRING_REQUEST)
        activity.registerReceiver(receiver, intent)
    }

    /**
     * 反注册广播
     */
    fun unregisterReceiver(context: Context, receiver: BroadcastReceiver) {
        context.unregisterReceiver(receiver)
        if (BluetoothUtils.getBluetoothAdapter(context) != null)
            BluetoothUtils.getBluetoothAdapter(context).cancelDiscovery()
    }


    /**
     *打开客户端线程
     */
    fun startClientThread(device: BluetoothDevice) {
        if (mClientThread == null) {
            synchronized(this) {
                if (mClientThread == null) {
                    mClientThread = ClientThread(device, getUUID())
                    mClientThread?.start()
                }
            }
        }
    }

    /**
     * 打开服务端线程
     */
    fun startServerThread(context: Context) {
        if (mServerThread == null) {
            synchronized(this) {
                if (mServerThread == null) {
                    mServerThread = ServerThread(context, getUUID())
                    mServerThread?.start()
                }
            }
        }

    }

    /**
     * 发送数据
     */
    fun sendMessageHandle(context: Context, msg: String) {
        LogUtils.e(msg)
        if (mSocket == null) {
            Toast.makeText(context, "没有连接", Toast.LENGTH_SHORT).show()
            return
        }
        try {
            val os = mSocket?.getOutputStream()
            os?.write(msg.toByteArray())
        } catch (e: IOException) {
            e.printStackTrace()
        }
    }

    /**
     * 停止客户端连接
     */
    fun shutdownClient() {
        object : Thread() {
            override fun run() {
                if (mClientThread != null) {
                    mClientThread?.interrupt()
                }
                if (mReadThread != null) {
                    mReadThread?.interrupt()
                }
                if (mSocket != null) {
                    try {
                        mSocket?.close()
                    } catch (e: IOException) {
                        e.printStackTrace()
                    }
                }
            }
        }.start()
    }

    /**
     * 停止服务器
     */
    fun shutdownServer() {
        object : Thread() {
            override fun run() {
                if (mServerThread != null) {
                    mServerThread?.interrupt()
                }
                if (mReadThread != null) {
                    mReadThread?.interrupt()
                }
                try {
                    if (mSocket != null) {
                        mSocket?.close()
                    }
                    if (mServerSocket != null) {
                        mServerSocket?.close()
                    }
                } catch (e: IOException) {
                    e.printStackTrace()
                }

            }
        }.start()
    }

    /**
     * 反射获取本地蓝牙地址
     */
    fun getBtAddressByReflection(): String? {
        val bluetoothAdapter = BluetoothAdapter.getDefaultAdapter()
        var field: Field?
        try {
            field = BluetoothAdapter::class.java.getDeclaredField("mService")
            field!!.setAccessible(true)
            val bluetoothManagerService = field!!.get(bluetoothAdapter) ?: return null
            val method = bluetoothManagerService.javaClass.getMethod("getAddress")
            if (method != null) {
                val obj = method.invoke(bluetoothManagerService)
                if (obj != null) {
                    return obj.toString()
                }
            }
        } catch (e: NoSuchFieldException) {
            e.printStackTrace()
        } catch (e: IllegalAccessException) {
            e.printStackTrace()
        } catch (e: NoSuchMethodException) {
            e.printStackTrace()
        } catch (e: InvocationTargetException) {
            e.printStackTrace()
        }
        return null
    }

    /**
     * 获取UUID
     */
    fun getUUID(): UUID {
        var uuid: UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
        try {
            val getUuidsMethod = BluetoothAdapter::class.java.getDeclaredMethod("getUuids")
            val uuids = getUuidsMethod.invoke(BluetoothAdapter.getDefaultAdapter(), null) as Array<ParcelUuid>
            for (uuid in uuids) {
                LogUtils.e(uuid.uuid)
            }
            uuid = uuids[0].uuid
        } catch (e: Exception) {
            e.printStackTrace()
        }
        return uuid
    }

    /**
     * 客户端线程
     */
    class ClientThread(device: BluetoothDevice, uuid: UUID) : Thread() {
        private lateinit var uuid: UUID

        init {
            this.uuid = uuid
            mSocket = device.createRfcommSocketToServiceRecord(uuid)
        }

        override fun run() {
            try {
                mSocket?.connect()
                LogUtils.e(1)
            } catch (e: IOException) {
                e.printStackTrace()
            }

        }
    }

    /**
     * 服务器线程
     */
    class ServerThread : Thread {
        private lateinit var context: Context
        private lateinit var uuid: UUID
        private var serverName = "defServerName"

        constructor(context: Context, uuid: UUID) {
            ServerThread(context,uuid,serverName)
        }

        constructor(context: Context, uuid: UUID, name: String) {
            this.context = context
            this.uuid = uuid
            this.serverName = name

            mServerSocket = getBluetoothAdapter(context).listenUsingRfcommWithServiceRecord(serverName,
                    uuid)
        }

        override fun run() {
            try {
                LogUtils.e(1)
                /* 接受客户端的连接请求 */
                mSocket = mServerSocket?.accept()
                mReadThread = ReadThread()
                mReadThread?.start()
            } catch (e: IOException) {
                e.printStackTrace()
                LogUtils.e(1)
            }
        }
    }

    /**
     * 读取数据线程.
     * 空参构造使用EventBus传递收到的消息.
     * 有参构造使用Handler传递收到的消息.
     */
    class ReadThread : Thread {
        private var handler: Handler? = null

        constructor() {
        }

        constructor(handler: Handler) {
            this.handler = handler
        }

        override fun run() {
            var input: InputStream? = null
            try {
                LogUtils.e(1)
                val buffer = ByteArray(1024)
                input = (mSocket as BluetoothSocket).getInputStream()
                while (true) {
                    var bytes = input.read(buffer)
                    if (bytes > 0) {
                        val buf_data = ByteArray(bytes)
                        for (i in 0..bytes - 1) {
                            buf_data[i] = buffer[i]
                        }
                        val s = String(buf_data)

                        if (handler != null) {
                            val msg: Message = Message()
                            msg.what = HANDLER_RECEIVE_MESSAGE
                            msg.obj = s
                            handler!!.sendMessage(msg)
                        }
                        EventBus.getDefault().post(s)
                    }
                }
            } catch (e1: IOException) {
                e1.printStackTrace()
            } finally {
                try {
                    if (input != null)
                        input.close()
                } catch (e1: IOException) {
                    e1.printStackTrace()
                }
            }

        }
    }

    /**
     * 绑定蓝牙
     */
    object Bonde {

        /**
         * 开始匹配
         */
        fun createBond(btDevice: BluetoothDevice): Boolean {
            return btDevice.createBond()
        }

        /**
         * 与设备解除配对
         */
        @Throws(Exception::class)
        fun removeBond(btClass: Class<*>, btDevice: BluetoothDevice): Boolean {
            val removeBondMethod = btClass.getMethod("removeBond")
            val returnValue = removeBondMethod.invoke(btDevice) as Boolean
            return returnValue
        }


        @Throws(Exception::class)
        fun setPin(btClass: Class<out BluetoothDevice>, btDevice: BluetoothDevice,
                   str: String): Boolean {
            try {
                val removeBondMethod = btClass.getDeclaredMethod("setPin",
                        *arrayOf<Class<*>>(ByteArray::class.java))
                val returnValue = removeBondMethod.invoke(btDevice,
                        arrayOf<Any>(str.toByteArray())) as Boolean
                Log.e("returnValue", "" + returnValue)
            } catch (e: SecurityException) {
                e.printStackTrace()
            } catch (e: IllegalArgumentException) {
                e.printStackTrace()
            } catch (e: Exception) {
                e.printStackTrace()
            }

            return true

        }

        /**
         * 取消用户输入
         */
        @Throws(Exception::class)
        fun cancelPairingUserInput(btClass: Class<*>,
                                   device: BluetoothDevice): Boolean {
            val createBondMethod = btClass.getMethod("cancelPairingUserInput")
            //        cancelBondProcess(btClass, device);
            val returnValue = createBondMethod.invoke(device) as Boolean
            return returnValue
        }

        /**
         * 取消配对
         */
        @Throws(Exception::class)
        fun cancelBondProcess(btClass: Class<*>,
                              device: BluetoothDevice): Boolean {
            val createBondMethod = btClass.getMethod("cancelBondProcess")
            val returnValue = createBondMethod.invoke(device) as Boolean
            return returnValue
        }

        /**
         * 确认配对
         */
        @Throws(Exception::class)
        fun setPairingConfirmation(btClass: Class<*>, device: BluetoothDevice, isConfirm: Boolean) {
            val setPairingConfirmation = btClass.getDeclaredMethod("setPairingConfirmation", Boolean::class.java)
            setPairingConfirmation.invoke(device, isConfirm)
        }


        /**
         * 取得所有方法
         * @param clsShow
         */
        fun printAllInform(clsShow: Class<*>) {
            try {
                // 取得所有方法
                val hideMethod = clsShow.methods
                var i = 0
                while (i < hideMethod.size) {
                    Log.e("method name", hideMethod[i].name + ";and the i is:"
                            + i)
                    i++
                }
                // 取得所有常量
                val allFields = clsShow.fields
                i = 0
                while (i < allFields.size) {
                    Log.e("Field name", allFields[i].name)
                    i++
                }
            } catch (e: SecurityException) {
                e.printStackTrace()
            } catch (e: IllegalArgumentException) {
                e.printStackTrace()
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }

    class BluetoothBroadcastReceiver : BroadcastReceiver() {
        //接收
        override fun onReceive(context: Context, intent: Intent) {
            val action = intent.getAction()
            val b = intent.getExtras()
            val lstName = b.keySet()
            // 显示所有收到的消息及其细节
            for (i in lstName) {
                val keyName = i.toString()
                Log.e("bluetooth", keyName + ">>>" + b.get(keyName))
            }

            var device: BluetoothDevice
            // 搜索发现设备时，取得设备的信息；注意，这里有可能重复搜索同一设备
            if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
                
            } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
                device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
                when (device.bondState) {
                    BluetoothDevice.BOND_BONDING//正在配对
                    -> {
                        LogUtils.e("正在配对......")
                    }
                    BluetoothDevice.BOND_BONDED//配对结束
                    -> {
                        LogUtils.e("完成配对")
                        //startMessageTest(device)
                    }
                    BluetoothDevice.BOND_NONE//取消配对/未配对
                    -> {
                        LogUtils.e("取消配对")
                    }
                }
                
            }
        }
    }
}
TomCat0916
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
[原创] Android应用使用蓝牙通信控制车联网设备(Kotlin实现)
妥啦的技术博客
02-07 9040
目录前言开发环境1. 步骤展示手机注册蓝牙通信Server端蓝牙设备注册Client端Android手机端通过蓝牙发送打开前门指令Android手机端通过蓝牙发送打开后备箱指令2. Android 蓝牙通信的基本介绍和实现步骤3. Android Automotive 实现驾驶模式的几种实现方式和代码示例方式一 .在Manifest文件中，使用在元数据meta-data对有可能造成分心驾驶的界面进行标记方式二 .使用CarDrivingStateManager类获取当前汽车的行驶状态，应用获取到行驶状态
android.bluetooth Kotlin |Java
BLOG域名:programb.blog.csdn.net
05-12 369
Provides classes that manage Bluetooth functionality, such as scanning for devices, connecting with devices, and managing data transfer between devices. The Bluetooth API supports both “Classic Bluetooth” and Bluetooth Low Energy. For more information abou
Kotlin BLE 库，为 Android 设备打造的高效蓝牙低功耗工具
最新发布
gitblog_00065的博客
06-01 320
Kotlin BLE 库，为 Android 设备打造的高效蓝牙低功耗工具 项目地址:https://gitcode.com/NordicSemiconductor/Kotlin-BLE-Library 项目介绍 Kotlin BLE Library 是一个专为 Android 平台设计的库，它简化了对 Android 蓝牙低功耗（Bluetooth Low Energy）的操作。库的核心理念是利...
Android kotlin 组件间通讯 - LiveEventBus 及测试(更新中)
彬sir哥的博客
02-28 1238
LiveEventBus是Android中组件间传递消息，支持AndroidX，Event：事件，Bus：总线。3、组件间通讯，第一个页面MainActivity.kt，第二个页面TestActivity。发送到第一个页面， 需要同时更新第一个页面该组件。范围全覆盖的消息总线解决方案。渠道Channel.kt。输入“欢迎你”后点击。
Android使用KOTLIN通过蓝牙接收Arduino发送的信息
shengk的博客
07-19 752
Android使用KOTLIN通过蓝牙接收Arduino发送的信息
Android 6.0 Kotlin 蓝牙扫描
weixin_30764137的博客
12-29 457
package com.arci.myapplicationimport android.app.Activityimport android.os.Bundleimport android.support.design.widget.Snackbarimport android.support.v7.app.AppCompatActivityimport android.view.Menuimp...
GDG_Android_Kotlin:GDG_Android_Kotlin
04-09
3. **数据类和领域模型**：Kotlin的内置数据类简化了对象的创建和操作，对于构建领域模型非常方便。 4. **Android组件的Kotlin实现**：如Activity、Fragment、Service等，以及如何使用Kotlin特性和语法优化它们。 5....
kotlin学习笔记
03-04
kotlin学习笔记，由我自己写的学习笔记，希望能和大家一起探讨kotlin
kotlin 加密算法工具类
01-08
在IT行业中，加密算法是...总之，Kotlin中的加密算法工具类集成了多种加密方法，为开发人员提供了方便的数据保护手段。在选择合适的加密算法时，应考虑性能、安全性以及应用场景，确保数据在传输和存储过程中的安全性。
EventsCalendar_kotlinandroid_kotlin_
10-01
【标题】"EventsCalendar_kotlinandroid_kotlin_" 指示这是一个使用Kotlin语言开发的Android日历应用，重点在于其包含多种动画效果。在Android应用开发中，Kotlin已经逐渐成为主流语言，以其简洁、安全和面向现代...
kotlin工具类.zip
03-30
通过这个"Kotlin工具类.zip"项目，我们可以学习到Kotlin语言的各种高级特性和最佳实践，提升我们的代码质量和开发效率。无论是在Android开发还是其他Kotlin应用中，这些工具类都能为我们的工作带来极大的便利。在...
Kotlin+Android 蓝牙基本操作
08-09
采用kotlin 对蓝牙进行打开和关闭，以及搜索蓝牙设备，与其他蓝牙设备配对，并将所有配对的信息进行显示。相关说明看 https://mp.csdn.net/mp_blog/creation/editor/119547298
Android 6.0 蓝牙ble 官方demo简化版
02-26
Android 6.0 蓝牙ble 官方demo简化版
WDK Bluetooth Headers
09-18
WDK Bluetooth Headers 好像是蓝牙设备的驱动开发头文件。
Android 蓝牙开发（扫描设备、绑定、解绑）Kotlin版
晨曦
11-18 5845
Kotlin版 蓝牙开发 （扫描设备、绑定、解绑）前言正文① 配置项目② 布局和样式 前言   之前写了一个蓝牙的小Demo，看的人还是有一些的，也有人私信我说，在学Kotlin，能不能出一版Kotlin的博客讲述这个蓝牙开发，这个想法还是不错的，不过就怕写了没有人看，因为在国内Kotlin是受众群体确实比较少，当然了也是有大的方向在往这边推动的，但是小公司依然不会去用Kotlin，如果你看不惯我这个说法也不要告诉我。我只是把这个博客当成是笔记而已，如果能在写作的时候帮助到别人也是乐意的，不能就自勉吧。
Android 蓝牙开发（扫描设备、绑定、解绑）Kotlin版(1)，2024年Android开发者跳槽指南
2401_84152308的博客
04-06 983
外链图片转存中…(img-IwfxvvY7-1712364273428)][外链图片转存中…(img-p1iX1HKI-1712364273429)][外链图片转存中…(img-KEFzjx0f-1712364273429)][外链图片转存中…(img-lBdJDbwC-1712364273430)][外链图片转存中…(img-Y64l8ofm-1712364273430)]
kotlin-接口
xh_ssh的博客
05-03 199
前言 二货老婆在写论文没时间没我玩耍，借此时间来写个博客讲讲 kotlin中的接口， 接口 kotlin中的接口和java8提供的相似，既包含抽象方法的声明也包括，也包含实现。 与抽象类不同的是接口无法保存状态，它可以有属性但是必须声明为抽象或者是提供访问器实现。 接口的定义 定义接口使用的是interface关键字 interface MyInterface{ fun max:Int() ...
低功耗蓝牙（BLE）和传感器的使用
qfguankefeng的博客
06-30 1114
一、低功耗蓝牙的使用 Android中关于蓝牙的开发文档，可以参考Google提供的官方蓝牙文档：https://developer.android.google.cn/guide/topics/connectivity/bluetooth.html 在Android开发中，应用可通过官方提供的蓝牙API执行以下操作： 扫描其他蓝牙设备 查询本地蓝牙适配器的配对蓝牙设备 建立 RFCOMM 通道 通过服务发现连接到其他设备 与其他设备进行双向数据传输 管理多个连接 蓝牙 一个近距离无线通信
Android 蓝牙获取不到服务（特性信息）
挖到尽头
05-22 7985
SYD8801是一款低功耗高性能蓝牙低功耗SOC，集成了高性能2.4GHz射频收发机、32位ARM Cortex-M0处理器、128kB Flash存储器、以及丰富的数字接口。SYD8801片上集成了Balun无需阻抗匹配网络、高效率DCDC降压转换器，适合用于可穿戴、物联网设备等。具体可咨询：http://www.sydtek.com/ 本文摘录于：http://blog.csdn.net/q...
kotlin写网络工具类
09-26
在otlin中编写网络工具类可以使用`companion object`来实现类似于Java的静态方法。可以直接使用`object`关键字来定义一个类使其变成一个单例类。以下是一个示例代码： ```kotlin import android.content.Context ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值