Android蓝牙开发浅析

最新推荐文章于 2024-05-11 20:53:55 发布
最新推荐文章于 2024-05-11 20:53:55 发布
阅读量620 收藏
点赞数
分类专栏： android

由于近期正在开发一个通过蓝牙进行数据传递的模块，在参考了有关资料，并详细阅读了Android的官方文档后，总结了Android中蓝牙模块的使用。

【更新】之前承诺的蓝牙通讯模块的源码已经放出，详情请点击一下链接

http://blog.csdn.net/gd920129/article/details/7552110


1. 使用蓝牙的响应权限

[html] view plain copy print ?
  1. <uses-permission android:name="android.permission.BLUETOOTH" /> 
  2. <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />  
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />


2. 配置本机蓝牙模块

在这里首先要了解对蓝牙操作一个核心类BluetoothAdapter

[java] view plain copy print ?
  1. BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); 
  2. //直接打开系统的蓝牙设置面板 
  3. Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); 
  4. startActivityForResult(intent, 0x1); 
  5. //直接打开蓝牙 
  6. adapter.enable(); 
  7. //关闭蓝牙 
  8. adapter.disable(); 
  9. //打开本机的蓝牙发现功能（默认打开120秒，可以将时间最多延长至300秒） 
  10. Intent discoveryIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); 
  11. discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);//设置持续时间（最多300秒）  
BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
//直接打开系统的蓝牙设置面板
Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(intent, 0x1);
//直接打开蓝牙
adapter.enable();
//关闭蓝牙
adapter.disable();
//打开本机的蓝牙发现功能（默认打开120秒，可以将时间最多延长至300秒）
Intent discoveryIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);//设置持续时间（最多300秒）


3.搜索蓝牙设备

使用BluetoothAdapter的startDiscovery()方法来搜索蓝牙设备

startDiscovery()方法是一个异步方法，调用后会立即返回。该方法会进行对其他蓝牙设备的搜索，该过程会持续12秒。该方法调用后，搜索过程实际上是在一个System Service中进行的，所以可以调用cancelDiscovery()方法来停止搜索（该方法可以在未执行discovery请求时调用）。

请求Discovery后，系统开始搜索蓝牙设备，在这个过程中，系统会发送以下三个广播：

ACTION_DISCOVERY_START：开始搜索

ACTION_DISCOVERY_FINISHED：搜索结束

ACTION_FOUND：找到设备，这个Intent中包含两个extra fields：EXTRA_DEVICE和EXTRA_CLASS，分别包含BluetooDevice和BluetoothClass。

我们可以自己注册相应的BroadcastReceiver来接收响应的广播，以便实现某些功能

[java] view plain copy print ?
  1. // 创建一个接收ACTION_FOUND广播的BroadcastReceiver 
  2. private final BroadcastReceiver mReceiver = new BroadcastReceiver() { 
  3.     public void onReceive(Context context, Intent intent) { 
  4.         String action = intent.getAction(); 
  5.         // 发现设备 
  6.         if (BluetoothDevice.ACTION_FOUND.equals(action)) { 
  7.             // 从Intent中获取设备对象 
  8.             BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE); 
  9.             // 将设备名称和地址放入array adapter，以便在ListView中显示 
  10.             mArrayAdapter.add(device.getName() + "\n" + device.getAddress()); 
  11.         } 
  12.     } 
  13. }; 
  14. // 注册BroadcastReceiver 
  15. IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND); 
  16. registerReceiver(mReceiver, filter); // 不要忘了之后解除绑定  
// 创建一个接收ACTION_FOUND广播的BroadcastReceiver
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        // 发现设备
        if (BluetoothDevice.ACTION_FOUND.equals(action)) {
            // 从Intent中获取设备对象
            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            // 将设备名称和地址放入array adapter，以便在ListView中显示
            mArrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
};
// 注册BroadcastReceiver
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter); // 不要忘了之后解除绑定



4. 蓝牙Socket通信

如果打算建议两个蓝牙设备之间的连接，则必须实现服务器端与客户端的机制。当两个设备在同一个RFCOMM channel下分别拥有一个连接的BluetoothSocket，这两个设备才可以说是建立了连接。

服务器设备与客户端设备获取BluetoothSocket的途径是不同的。服务器设备是通过accepted一个incoming connection来获取的，而客户端设备则是通过打开一个到服务器的RFCOMM channel来获取的。


服务器端的实现

通过调用BluetoothAdapter的listenUsingRfcommWithServiceRecord(String, UUID)方法来获取BluetoothServerSocket（UUID用于客户端与服务器端之间的配对）

调用BluetoothServerSocket的accept()方法监听连接请求，如果收到请求，则返回一个BluetoothSocket实例（此方法为block方法，应置于新线程中）

如果不想在accept其他的连接，则调用BluetoothServerSocket的close()方法释放资源（调用该方法后，之前获得的BluetoothSocket实例并没有close。但由于RFCOMM一个时刻只允许在一条channel中有一个连接，则一般在accept一个连接后，便close掉BluetoothServerSocket）

[java] view plain copy print ?
  1. private class AcceptThread extends Thread { 
  2.     private final BluetoothServerSocket mmServerSocket; 
  3.  
  4.     public AcceptThread() { 
  5.         // Use a temporary object that is later assigned to mmServerSocket, 
  6.         // because mmServerSocket is final 
  7.         BluetoothServerSocket tmp = null; 
  8.         try { 
  9.             // MY_UUID is the app's UUID string, also used by the client code 
  10.             tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID); 
  11.         } catch (IOException e) { } 
  12.         mmServerSocket = tmp; 
  13.     } 
  14.  
  15.     public void run() { 
  16.         BluetoothSocket socket = null; 
  17.         // Keep listening until exception occurs or a socket is returned 
  18.         while (true) { 
  19.             try { 
  20.                 socket = mmServerSocket.accept(); 
  21.             } catch (IOException e) { 
  22.                 break; 
  23.             } 
  24.             // If a connection was accepted 
  25.             if (socket != null) { 
  26.                 // Do work to manage the connection (in a separate thread) 
  27.                 manageConnectedSocket(socket); 
  28.                 mmServerSocket.close(); 
  29.                 break; 
  30.             } 
  31.         } 
  32.     } 
  33.  
  34.     /** Will cancel the listening socket, and cause the thread to finish */ 
  35.     public void cancel() { 
  36.         try { 
  37.             mmServerSocket.close(); 
  38.         } catch (IOException e) { } 
  39.     } 
  40. }  
private class AcceptThread extends Thread {
    private final BluetoothServerSocket mmServerSocket;

    public AcceptThread() {
        // Use a temporary object that is later assigned to mmServerSocket,
        // because mmServerSocket is final
        BluetoothServerSocket tmp = null;
        try {
            // MY_UUID is the app's UUID string, also used by the client code
            tmp = mBluetoothAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }

    public void run() {
        BluetoothSocket socket = null;
        // Keep listening until exception occurs or a socket is returned
        while (true) {
            try {
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }
            // If a connection was accepted
            if (socket != null) {
                // Do work to manage the connection (in a separate thread)
                manageConnectedSocket(socket);
                mmServerSocket.close();
                break;
            }
        }
    }

    /** Will cancel the listening socket, and cause the thread to finish */
    public void cancel() {
        try {
            mmServerSocket.close();
        } catch (IOException e) { }
    }
}



客户端的实现

通过搜索得到服务器端的BluetoothService

调用BluetoothService的listenUsingRfcommWithServiceRecord(String, UUID)方法获取BluetoothSocket（该UUID应该同于服务器端的UUID）

调用BluetoothSocket的connect()方法（该方法为block方法），如果UUID同服务器端的UUID匹配，并且连接被服务器端accept，则connect()方法返回

注意：在调用connect()方法之前，应当确定当前没有搜索设备，否则连接会变得非常慢并且容易失败

[java] view plain copy print ?
  1. private class ConnectThread extends Thread { 
  2.     private final BluetoothSocket mmSocket; 
  3.     private final BluetoothDevice mmDevice; 
  4.  
  5.     public ConnectThread(BluetoothDevice device) { 
  6.         // Use a temporary object that is later assigned to mmSocket, 
  7.         // because mmSocket is final 
  8.         BluetoothSocket tmp = null; 
  9.         mmDevice = device; 
  10.  
  11.         // Get a BluetoothSocket to connect with the given BluetoothDevice 
  12.         try { 
  13.             // MY_UUID is the app's UUID string, also used by the server code 
  14.             tmp = device.createRfcommSocketToServiceRecord(MY_UUID); 
  15.         } catch (IOException e) { } 
  16.         mmSocket = tmp; 
  17.     } 
  18.  
  19.     public void run() { 
  20.         // Cancel discovery because it will slow down the connection 
  21.         mBluetoothAdapter.cancelDiscovery(); 
  22.  
  23.         try { 
  24.             // Connect the device through the socket. This will block 
  25.             // until it succeeds or throws an exception 
  26.             mmSocket.connect(); 
  27.         } catch (IOException connectException) { 
  28.             // Unable to connect; close the socket and get out 
  29.             try { 
  30.                 mmSocket.close(); 
  31.             } catch (IOException closeException) { } 
  32.             return; 
  33.         } 
  34.  
  35.         // Do work to manage the connection (in a separate thread) 
  36.         manageConnectedSocket(mmSocket); 
  37.     } 
  38.  
  39.     /** Will cancel an in-progress connection, and close the socket */ 
  40.     public void cancel() { 
  41.         try { 
  42.             mmSocket.close(); 
  43.         } catch (IOException e) { } 
  44.     } 
  45. }  
private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;

    public ConnectThread(BluetoothDevice device) {
        // Use a temporary object that is later assigned to mmSocket,
        // because mmSocket is final
        BluetoothSocket tmp = null;
        mmDevice = device;

        // Get a BluetoothSocket to connect with the given BluetoothDevice
        try {
            // MY_UUID is the app's UUID string, also used by the server code
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }

    public void run() {
        // Cancel discovery because it will slow down the connection
        mBluetoothAdapter.cancelDiscovery();

        try {
            // Connect the device through the socket. This will block
            // until it succeeds or throws an exception
            mmSocket.connect();
        } catch (IOException connectException) {
            // Unable to connect; close the socket and get out
            try {
                mmSocket.close();
            } catch (IOException closeException) { }
            return;
        }

        // Do work to manage the connection (in a separate thread)
        manageConnectedSocket(mmSocket);
    }

    /** Will cancel an in-progress connection, and close the socket */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}



连接管理（数据通信）

分别通过BluetoothSocket的getInputStream()和getOutputStream()方法获取InputStream和OutputStream

使用read(bytes[])和write(bytes[])方法分别进行读写操作

注意：read(bytes[])方法会一直block，知道从流中读取到信息，而write(bytes[])方法并不是经常的block（比如在另一设备没有及时read或者中间缓冲区已满的情况下，write方法会block）

[java] view plain copy print ?
  1. private class ConnectedThread extends Thread { 
  2.     private final BluetoothSocket mmSocket; 
  3.     private final InputStream mmInStream; 
  4.     private final OutputStream mmOutStream; 
  5.  
  6.     public ConnectedThread(BluetoothSocket socket) { 
  7.         mmSocket = socket; 
  8.         InputStream tmpIn = null; 
  9.         OutputStream tmpOut = null; 
  10.  
  11.         // Get the input and output streams, using temp objects because 
  12.         // member streams are final 
  13.         try { 
  14.             tmpIn = socket.getInputStream(); 
  15.             tmpOut = socket.getOutputStream(); 
  16.         } catch (IOException e) { } 
  17.  
  18.         mmInStream = tmpIn; 
  19.         mmOutStream = tmpOut; 
  20.     } 
  21.  
  22.     public void run() { 
  23.         byte[] buffer = new byte[1024];  // buffer store for the stream 
  24.         int bytes; // bytes returned from read() 
  25.  
  26.         // Keep listening to the InputStream until an exception occurs 
  27.         while (true) { 
  28.             try { 
  29.                 // Read from the InputStream 
  30.                 bytes = mmInStream.read(buffer); 
  31.                 // Send the obtained bytes to the UI Activity 
  32.                 mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer) 
  33.                         .sendToTarget(); 
  34.             } catch (IOException e) { 
  35.                 break; 
  36.             } 
  37.         } 
  38.     } 
  39.  
  40.     /* Call this from the main Activity to send data to the remote device */ 
  41.     public void write(byte[] bytes) { 
  42.         try { 
  43.             mmOutStream.write(bytes); 
  44.         } catch (IOException e) { } 
  45.     } 
  46.  
  47.     /* Call this from the main Activity to shutdown the connection */ 
  48.     public void cancel() { 
  49.         try { 
  50.             mmSocket.close(); 
  51.         } catch (IOException e) { } 
  52.     } 
  53. }  
private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;

    public ConnectedThread(BluetoothSocket socket) {
        mmSocket = socket;
        InputStream tmpIn = null;
        OutputStream tmpOut = null;

        // Get the input and output streams, using temp objects because
        // member streams are final
        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) { }

        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }

    public void run() {
        byte[] buffer = new byte[1024];  // buffer store for the stream
        int bytes; // bytes returned from read()

        // Keep listening to the InputStream until an exception occurs
        while (true) {
            try {
                // Read from the InputStream
                bytes = mmInStream.read(buffer);
                // Send the obtained bytes to the UI Activity
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer)
                        .sendToTarget();
            } catch (IOException e) {
                break;
            }
        }
    }

    /* Call this from the main Activity to send data to the remote device */
    public void write(byte[] bytes) {
        try {
            mmOutStream.write(bytes);
        } catch (IOException e) { }
    }

    /* Call this from the main Activity to shutdown the connection */
    public void cancel() {
        try {
            mmSocket.close();
        } catch (IOException e) { }
    }
}


引用资料：Android官方SDK、《Android/OPhone完全开发讲义》

lg19870311
关注
专栏目录
Android 蓝牙开发（一）蓝牙通信
奋斗的菜鸟ing
06-07 6万+
随着可穿戴设备的流行，研究蓝牙是必不可少的一门技术了。 总结了下蓝牙开发使用的一些东西分享一下。 首先需要AndroidManifest.xml文件中添加操作蓝牙的权限。 <uses-permissionandroid:name="android.permission.BLUETOOTH" /> 允许程序连接到已配对的蓝牙设备。 <uses-permissionandro
Android Wear开发浅析（一）
ˉ夨落旳尐孩的专栏
02-16 6616
Android Wear究竟是什么？Android Wear和手机是完全不同的设计理念：手机大多数情况下，都是用户去操作，去触发里面的应用；而手表则是“用户被动”的，用户越少感觉到你的存在，越是合理，而在某些场景下给予最合适的提醒，则是Android Wear最伟大的设计理念，这也是它想做到的。Android Wear是智能的通知栏！（个人理解）在早上醒来的时候，给你推送早上的天气、交通状况。在你...
android -------- 蓝牙通信
weixin_33720956的博客
04-17 112
前面介绍了蓝牙的一些知识，今天来聊一聊蓝牙之间的通信，实现两个设备通信。 我用两部手机实现相互发消息的功能   无论是BluetoothSocket，还是BluetoothServerSocket，都需要一个UUID（全局唯一标识符,UniversallyUnique Identifier）   蓝牙的UUID 两个蓝牙设备进行连接时需要使用同一个UUID。但很多读者可能发现，有很多型号的手机（可...
android用于蓝牙通信的 BluetoothSocketHelper类
03-03
android下的蓝牙通信类，简化蓝牙通信的开发，类的位置在资源的tq\com\app\lib\Util\BlueToothUtil下面。整个资源是一个实例。扫描附近符合条件的蓝牙基站并显示出来，同时维护蓝牙基站的状态。
Android 蓝牙 socket通信
weixin_42602900的博客
05-14 1390
Android中蓝牙模块的使用 使用蓝牙API，Android应用程序能够执行以下功能： 扫描其他蓝牙设备查询本地已经配对的蓝牙适配器建立RFCOMM通道 通过服务发现来连接其他设备 在设备间传输数据 管理多个蓝牙连接 本文介绍如何使用Android的蓝牙API来完成使用蓝牙通信所需要的四项主要任务：设置蓝牙、查找已配对或区域内可用的蓝牙设备、连接设备、设备间传输数据。 1. 使用蓝牙的响应权限 <uses-permission android:name="android.permissio
浅析Wakelock机制与Android电源管理.pdf
09-21
例如，在Android操作系统中，有很多组件需要使用Wakelock机制来控制设备的休眠和唤醒，如Wi-Fi模块、蓝牙模块等。此外，Wakelock机制也可以用于实现设备的省电模式。在省电模式下，设备可以关闭不必要的设备，降低...
Android 蓝牙BLE开发详解
热门推荐
Charon1997的博客
06-07 1万+
Android 蓝牙BLE开发详解 有传输数据 多设备连接 获取uuid等
BLE蓝牙设备开发
qq_40259429的博客
03-15 1万+
（ps. 根据网上的知识进行的学习总结） 1、蓝牙模块概述 1.1 蓝牙模块 蓝牙，是一种支持设备短距离通信（一般10m内）的无线电技术，能在包括移动电话、PDA、无线耳机、笔记本电脑、相关外设等众多设备之间进行无线信息交换。利用“蓝牙”技术，能够有效地简化移动通信终端设备之间的通信，也能够成功地简化设备与因特网Internet之间的通信，从而数据传输变得更加迅速高效，为无线通信拓宽道路。蓝牙采用分散式网络结构以及快跳频和短包技术，支持点对点及点对多点通信，工作在全球通用的2.4GHz ISM（即工业、科
Android开发之蓝牙Socket
weixin_33905756的博客
04-22 75
蓝牙Server端就是通过线程来注册一个具有名称和唯一识别的UUID号的BluetoothServerSocket, 然后就一直监听Client端(BluetoothSocket)的请求，并对这些请求做出相应的处理。 // 注册蓝牙Server BleutoothAdapter bluetooth = BluetoothAdapter.getDefaultAdapter();//该静态方法可以...
【Android:BluetoothSocket】
qq_45106034的博客
05-24 908
BluetoothSocket public final class BluetoothSocket extends Object implements Closeable java.lang.Object : android.bluetooth.BluetoothSocket 文章目录BluetoothSocket前言注意：需要 BLUETOOTH权限。一、总结二、常量TYPE_L2CAPTYPE_RFCOMMTYPE_SCO三、Public methods 前言 连接或连接蓝牙插座。 蓝
Android BluetoothSocket
最新发布
liuning1985622的博客
05-11 886
BluetoothSocket是Android中用于在蓝牙设备之间进行数据传输的一种Socket。它提供了一种类似于TCP/IP协议的数据传输方式，可以在两个设备之间建立一个虚拟的通信管道，使得两个设备之间可以进行数据的传输和接收。BluetoothSocket可以用于客户端和服务端之间的通信，通过BluetoothSocket可以实现数据的双向传输。
Android 蓝牙通信
smallyellower的博客
07-10 471
1，关于蓝牙 随着这几年的发展现在越来越多的场景会用到蓝牙技术，最近非常火的共享单车都提供了打开蓝牙快速解锁的功能。它最为近场通信的一种，我们很有必要对它进行下研究和探索。 2，使用蓝牙   上图是手机设置中蓝牙界面。 1，当打开蓝牙时会在通知栏中有蓝牙图表展示 2，加载按钮，点击后取搜寻周围蓝牙设备。 3，打开关闭蓝牙的togglebutton 4，开发检测，关闭后周
【Android】使用BluetoothSocket实现跨设备通讯
little_fat_sheep
10-08 6361
1 前言 使用Socket实现跨设备通讯中介绍了使用 WiFi 通道实现跨设备通讯，本文将介绍使用 Bluetooth 通道实现跨进程通讯。 1.1 蓝牙通讯核心类 在蓝牙通讯中，主要用到 BluetoothAdapter、BluetoothDevice、BluetoothServerSocket、BluetoothSocket。 （1）BluetoothAdapter public static synchronized BluetoothAdapter getDefaultAdapter(.
Android学习笔记26——蓝牙Socket通信
裕博的博客
10-10 1390
蓝牙Socket通信 UUID 在蓝牙中，每个服务和服务属性都唯一地由 全局唯一标识符 ,Universally Unique Identifier（UUID）来校验。正如它的名字所暗示的，每一个这样的标识符都要在时空上保证唯一。UUID类可表现为短整形（16或32位）和长整形（128 位）UUID。他提供了分别利用String和16位或32位数值来创建类的构造函数，提供了一个可以比较两个UUID...
基于蓝牙socket开发Android蓝牙通信
jingwenjingwen的专栏
07-09 238
[url]http://www.cyqdata.com/android/article-detail-53225#[/url] 如何实现Android蓝牙通信？一般通过使用蓝牙虚拟串口，可以通过配置非常简单地实现，很多外置蓝牙GPS都用这种做法。 然而Android却不支持，因此不得不得使用第二种方式：蓝牙socket。 本示例不使用C++开发，借助于第三方.NET组件inthehand...
Android蓝牙通信
思月行云
11-18 2622
http://blog.csdn.net/menghnhhuan/article/details/7057484/ 这里使用的是RFCOMM协议，RFCOMM是一个简单的串行线性仿真协议，此协议提供RS232控制和状态信号。 也就是一个串口（COM）传输协议，波特率为9600，8位数据。所以手机蓝牙可以与另外的蓝牙设备进行通信。 两个设备进行通信，需要建立一个服务端和一个服务端，客户端连接上
进行蓝牙连接的两种方式
weixin_30260399的博客
10-25 834
为了在两台设备间创建一个连接，必须实现服务器端和客户端的机制，因为一个设备必须打开一个Server Socket，而另一个必须发起连接（使用服务器端设备的MAC地址发起连接）。当服务器端和客户端在同一个RFCOMM信道上都有一个BluetoothSocket时，则两端就建立了连接。此刻，每个设备都能获得一个输入输出流，进行数据传输。服务器端和客户端获得BluetoothSocket的方法是不同的，...
浅析Android开发入门全攻略：从搭建到实战
它特别适合那些已经有编程基础，尤其是熟悉Java的读者，因为它从搭建Android开发环境开始，逐步引导读者创建一个完整的Android应用。作者通过清晰、简洁的语言和详尽的步骤，将复杂的Android技术分解为易于理解的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值