Android系统中串口的打开从Java到c层

最新推荐文章于 2025-03-03 16:34:54 发布
最新推荐文章于 2025-03-03 16:34:54 发布
阅读量1.3k 收藏 3
点赞数 1
分类专栏： 其它 文章标签： SerialPort Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Visrul/article/details/79434313
版权

Jni层代码

#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <jni.h>

#include "android_comport_SerialPort.h"

#include "android/log.h"
static const char *TAG="serial_port";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO,  TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)

static speed_t getBaudrate(jint baudrate)
{
	switch(baudrate) {
	case 0: return B0;
	case 50: return B50;
	case 75: return B75;
	case 110: return B110;
	case 134: return B134;
	case 150: return B150;
	case 200: return B200;
	case 300: return B300;
	case 600: return B600;
	case 1200: return B1200;
	case 1800: return B1800;
	case 2400: return B2400;
	case 4800: return B4800;
	case 9600: return B9600;
	case 19200: return B19200;
	case 38400: return B38400;
	case 57600: return B57600;
	case 115200: return B115200;
	case 230400: return B230400;
	case 460800: return B460800;
	case 500000: return B500000;
	case 576000: return B576000;
	case 921600: return B921600;
	case 1000000: return B1000000;
	case 1152000: return B1152000;
	case 1500000: return B1500000;
	case 2000000: return B2000000;
	case 2500000: return B2500000;
	case 3000000: return B3000000;
	case 3500000: return B3500000;
	case 4000000: return B4000000;
	default: return -1;
	}
}

/*
 * Class:     android_serialport_SerialPort
 * Method:    open
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_android_comport_SerialPort_open
  (JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)
{
	int fd;
	speed_t speed;
	jobject mFileDescriptor;

	/* Check arguments */
	{
		speed = getBaudrate(baudrate);
		if (speed == -1) {
			/* TODO: throw an exception */
			LOGE("Invalid baudrate");
			return NULL;
		}
	}

	/* Opening device */
	{
		jboolean iscopy;
		const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
		LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
		fd = open(path_utf, O_RDWR | flags);
		LOGD("open() fd = %d", fd);
		(*env)->ReleaseStringUTFChars(env, path, path_utf);
		if (fd == -1)
		{
			/* Throw an exception */
			LOGE("Cannot open port");
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Configure device */
	{
		struct termios cfg;
		LOGD("Configuring serial port");
		if (tcgetattr(fd, &cfg))
		{
			LOGE("tcgetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}

		cfmakeraw(&cfg);
		cfsetispeed(&cfg, speed);
		cfsetospeed(&cfg, speed);

		if (tcsetattr(fd, TCSANOW, &cfg))
		{
			LOGE("tcsetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Create a corresponding file descriptor */
	{
		jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
		jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
		jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
		mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
		(*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
	}

	return mFileDescriptor;
}

/*
 * Class:     cedric_serial_SerialPort
 * Method:    close
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_android_comport_SerialPort_close
  (JNIEnv *env, jobject thiz)
{
	jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
	jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

	jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
	jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

	jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
	jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

	LOGD("close(fd = %d)", descriptor);
	close(descriptor);
}


/*
 * Class:     android_serialport_SerialPort
 * Method:    open BlueTooth
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_android_comport_SerialPort_openBlueTooth
  (JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)
{
	int fd;
	speed_t speed;
	jobject mFileDescriptor;

	/* Check arguments */
	{
		speed = getBaudrate(baudrate);
		if (speed == -1) {
			/* TODO: throw an exception */
			LOGE("Invalid baudrate");
			return NULL;
		}
	}

	/* Opening device */
	{
		jboolean iscopy;
		const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
		LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
		fd = open(path_utf, O_RDWR | flags);
		LOGD("open() fd = %d", fd);
		(*env)->ReleaseStringUTFChars(env, path, path_utf);
		if (fd == -1)
		{
			/* Throw an exception */
			LOGE("Cannot open port");
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Configure device */
	{
		struct termios cfg;
		LOGD("Configuring serial port");
		if (tcgetattr(fd, &cfg))
		{
			LOGE("tcgetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}

		cfmakeraw(&cfg);
		cfsetispeed(&cfg, speed);
		cfsetospeed(&cfg, speed);

		if (tcsetattr(fd, TCSANOW, &cfg))
		{
			LOGE("tcsetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Create a corresponding file descriptor */
	{
		jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
		jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
		jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
		mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
		(*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
	}

	return mFileDescriptor;
}

JNIEXPORT void JNICALL Java_android_comport_SerialPort_closeBlueTooth
  (JNIEnv *env, jobject thiz)
{
	jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
	jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

	jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
	jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

	jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
	jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

	LOGD("close(fd = %d)", descriptor);
	close(descriptor);
}

/*
 * Class:     android_serialport_SerialPort
 * Method:    open BlueTooth
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_android_comport_SerialPort_openTps
  (JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)
{
	int fd;
	speed_t speed;
	jobject mFileDescriptor;

	/* Check arguments */
	{
		speed = getBaudrate(baudrate);
		if (speed == -1) {
			/* TODO: throw an exception */
			LOGE("Invalid baudrate");
			return NULL;
		}
	}

	/* Opening device */
	{
		jboolean iscopy;
		const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
		LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
		fd = open(path_utf, O_RDWR | flags);
		LOGD("open() fd = %d", fd);
		(*env)->ReleaseStringUTFChars(env, path, path_utf);
		if (fd == -1)
		{
			/* Throw an exception */
			LOGE("Cannot open port");
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Configure device */
	{
		struct termios cfg;
		LOGD("Configuring serial port");
		if (tcgetattr(fd, &cfg))
		{
			LOGE("tcgetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}

		cfmakeraw(&cfg);
		cfsetispeed(&cfg, speed);
		cfsetospeed(&cfg, speed);

		if (tcsetattr(fd, TCSANOW, &cfg))
		{
			LOGE("tcsetattr() failed");
			close(fd);
			/* TODO: throw an exception */
			return NULL;
		}
	}

	/* Create a corresponding file descriptor */
	{
		jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
		jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
		jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
		mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
		(*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
	}

	return mFileDescriptor;
}

JNIEXPORT void JNICALL Java_android_comport_SerialPort_closeTps
  (JNIEnv *env, jobject thiz)
{
	jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
	jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

	jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
	jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

	jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
	jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

	LOGD("close(fd = %d)", descriptor);
	close(descriptor);
}

再根据jni调用的c方法，不同api的调用基本一样，这里就不做过多的研究了

Java层

package android.comport;

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import android.util.Log;

public class SerialPort {

	private static final String TAG = "SerialPort";

	/*
	 * Do not remove or rename the field mFd: it is used by native method close();
	 */
	private FileDescriptor mFd;
	private FileInputStream mFileInputStream;
	private FileOutputStream mFileOutputStream;

	public SerialPort(File device, int baudrate, int flags) throws SecurityException, IOException {

		/* Check access permission */
		if (!device.canRead() || !device.canWrite()) {
			try {
				/* Missing read/write permission, trying to chmod the file */
				Process su;
				su = Runtime.getRuntime().exec("/system/bin/su");
				String cmd = "chmod 666 " + device.getAbsolutePath() + "\n"
						+ "exit\n";
				su.getOutputStream().write(cmd.getBytes());
				if ((su.waitFor() != 0) || !device.canRead()
						|| !device.canWrite()) {
					throw new SecurityException();
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new SecurityException();
			}
		}

		mFd = open(device.getAbsolutePath(), baudrate, flags);
		if (mFd == null) {
			Log.e(TAG, "native open returns null");
			throw new IOException();
		}
		mFileInputStream = new FileInputStream(mFd);
		mFileOutputStream = new FileOutputStream(mFd);
	}

	// Getters and setters
	public InputStream getInputStream() {
		return mFileInputStream;
	}

	public OutputStream getOutputStream() {
		return mFileOutputStream;
	}

	public void serialClose() {
		close();
	}
	
	// JNI
	private native static FileDescriptor open(String path, int baudrate, int flags);
	private native void close();
	static {
		System.loadLibrary("serial_port");
	}
	
/***********************************************************************************/
	private FileDescriptor mFd1;
	private FileInputStream mFileInputStream1;
	private FileOutputStream mFileOutputStream1;

	public SerialPort(File device, int baudrate, int flags,int bluetooth) throws SecurityException, IOException {

		/* Check access permission */
		if (!device.canRead() || !device.canWrite()) {
			try {
				/* Missing read/write permission, trying to chmod the file */
				Process su;
				su = Runtime.getRuntime().exec("/system/bin/su");
				String cmd = "chmod 666 " + device.getAbsolutePath() + "\n"
						+ "exit\n";
				su.getOutputStream().write(cmd.getBytes());
				if ((su.waitFor() != 0) || !device.canRead()
						|| !device.canWrite()) {
					throw new SecurityException();
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new SecurityException();
			}
		}

		mFd1 = openBlueTooth(device.getAbsolutePath(), baudrate, flags);
		if (mFd1 == null) {
			Log.e(TAG, "native open returns null");
			throw new IOException();
		}
		mFileInputStream1 = new FileInputStream(mFd1);
		mFileOutputStream1 = new FileOutputStream(mFd1);
	}

	// Getters and setters
	public InputStream getBlueToothInputStream() {
		return mFileInputStream1;
	}

	public OutputStream getBlueToothOutputStream() {
		return mFileOutputStream1;
	}

	public void serialBlueToothClose() {
		close();
	}
	
	// JNI
	private native static FileDescriptor openBlueTooth(String path, int baudrate, int flags);
	private native void closeBlueTooth();
	static {
		System.loadLibrary("serial_port");
	}

/***********************************************************************************/
	private FileDescriptor mFd2;
	private FileInputStream mFileInputStream2;
	private FileOutputStream mFileOutputStream2;

	public SerialPort(File device, int baudrate, int flags,boolean tps) throws SecurityException, IOException {

		/* Check access permission */
		if (!device.canRead() || !device.canWrite()) {
			try {
				/* Missing read/write permission, trying to chmod the file */
				Process su;
				su = Runtime.getRuntime().exec("/system/bin/su");
				String cmd = "chmod 666 " + device.getAbsolutePath() + "\n"
						+ "exit\n";
				su.getOutputStream().write(cmd.getBytes());
				if ((su.waitFor() != 0) || !device.canRead()
						|| !device.canWrite()) {
					throw new SecurityException();
				}
			} catch (Exception e) {
				e.printStackTrace();
				throw new SecurityException();
			}
		}

		mFd2 = openBlueTooth(device.getAbsolutePath(), baudrate, flags);
		if (mFd2 == null) {
			Log.e(TAG, "native open returns null");
			throw new IOException();
		}
		mFileInputStream2 = new FileInputStream(mFd2);
		mFileOutputStream2 = new FileOutputStream(mFd2);
	}

	// Getters and setters
	public InputStream getTpsInputStream() {
		return mFileInputStream2;
	}

	public OutputStream getTpsOutputStream() {
		return mFileOutputStream2;
	}

	public void serialTpsClose() {
		closeTps();
	}
	
	// JNI
	private native static FileDescriptor openTps(String path, int baudrate, int flags);
	private native void closeTps();

}

里面我封装了两打开方法，一个是Bluetooth的，一个是串口的，两方法其实是可以共用的，那是我为了调试方便分了两个

实例化串口

	
	public SystemParse(){
		try {
			mSerialPort = new SerialPort(new File(path), baudrate, flag1);
				        // "/dev/ttyS4"gpio设备路径   波特率115200   默认为0（不要改）
			if(mSerialPort!=null){
				flag = true;
				mInputStream = mSerialPort.getInputStream();
				mOutputStream = mSerialPort.getOutputStream();
			}else{
				flag = false;
			}
		}catch (Exception e) {
			Log.e(TAG, "SerialPort IOException occurred: " + e);
			flag = false;
		}
	}
获取到读写流，串口实例化成功

希望能帮到各位。。。

 

 

安卓Android源码——安卓Android系统访问串口设备源码.zip
10-10
这个压缩包“安卓Android源码——安卓Android系统访问串口设备源码.zip”包含了实现这一功能的源代码，可以帮助开发者深入理解如何在Android平台上操作串行端口。 串口通信是一种古老的通信方式，但因其简单可靠，...
Android 手把手教你接入串口功能
z842463468的博客
11-24 6545
手把手教你实现 Android 串口
c#程序调试运行和直接运行结果不一样（串口通信）
weixin_53141359的博客
04-25 276
1.记录位置功能失效了，功能实现上是接收到串口数据后开一个线程异步处理完成后弹窗设置相关操作保存到数据库，直接运行是不知道是什么情况不会弹窗。2.感应位置功能我做的是感应到位置后弹窗感应不到后关闭，但是直接运行时弹窗刚出现就会被关闭。
android实现串口接入
最新发布
reset2021的博客
03-03 889
准备一个兼容Android的USB-to-Serial转换器。这些设备带有相应的驱动程序，确保它们与安卓系统的兼容性。在应用首次运行时，系统会根据连接的硬件设备自动触发intent。：确保你的安卓设备支持USB On-The-Go（OTG）。大多数现代手机都支持这一功能，但为了保险起见，可以在购买前确认或通过测试应用检测。请将 YOUR_VID 和 YOUR_PID 替换为你的串口设备的实际VID和PID。启动Android Studio，创建一个新的Android项目。通过添加以下依赖项到你的。
Android串口操作，简化android-serialport-api的demo的问题
zhaohangzhi的博客
02-17 1233
使用DEMO更改SDK版本运行会出现打开串口，APP崩溃的问题 原因在原DEMO为4.0.3，现在的DEMO是4.4.2。.SO文件不对，使用完全版本的.SO替换上就正常了。 但是自己使用NDK重新编译.SO不行，原因不明，编译完成的.SO大小其实的是相同的。使用NDK后ECLIPCE出现不能编译的问题，取消NDK的设置后正常。   真机测试中还是不能运行，原因猜测是真机没有SSY2这个串
android 串口一直打开_android串口通信
weixin_42131414的博客
02-22 352
转载时请注明出处和作者最近段时间一直在做android下串口通信的东东，大概功能是android系统端的ARM和系统外的一个MCU通信，通过android界面控制MCU上挂的设备，如radio、TV、BT等等，下面对这个过程作一个浅显的阐述，有错之处还望大家斧正……先来看一张图，如下：我是直接在HAL层中通过两个线程对串口的设备节点/dev/ttymxc1进行读和写的，相应的代码如下：1、init...
android java 串口通信_Android 串口编程原理和实现方式(附源码)
weixin_34221384的博客
02-22 974
提到串口编程，就不得不提到JNI，不得不提到JavaAPI中的文件描述符类：FileDescriptor。下面我分别对JNI、FileDescriptor以及串口的一些知识点和实现的源码进行分析说明。这里主要是参考了开源项目android-serialport-api。串口编程需要了解的基本知识点：对于串口编程，我们只需对串口进行一系列的设置，然后打开串口，这些操作我们可以参考串口调试助手的源码进...
jni.rar_Android jni_JAVA串口 JNI_android_android RS232_jni
09-23
1. **创建JNI接口**：在Java层定义JNI函数，声明要调用的C/C++方法。例如，可以定义一个`openSerialPort()`函数用于打开串口，`writeDataToSerialPort()`函数用于发送数据，`readDataFromSerialPort()`函数用于接收...
androidjava源码-AndroidSerialPort:Android串口通信封装库，包含Java、C源码，并提供了使用Demo
05-20
《AndroidSerialPort: 深入理解Android串口通信封装库》 在移动开发领域，尤其是在Android系统上，串口通信扮演着重要的角色，尤其在物联网(IoT)设备连接和嵌入式系统交互中。AndroidSerialPort是一个专门针对...
安卓Android源码——系统访问串口设备源码.zip
10-11
在访问串口时，通常会使用NDK编译C/C++库，然后通过JNI接口供Java层调用。 3. **SerialInterface**： "SerialInterface"可能是源码中的一个关键类，它可能实现了串口通信的基本功能，如打开/关闭串口、设置波特率...
java与android串口通信示例代码
06-13
Java与Android串口通信是设备间进行数据交互的一种常见方式，尤其在物联网和嵌入式系统中广泛应用。本文将深入探讨如何使用Java和Android进行串口通信，以及相关的技术细节。 首先，我们要知道什么是串口通信。串口...
Android 中的串口开发
XuChaofafa的博客
10-21 2708
串行端口 ，即：SerialPort，简称串口，主要用于数据被逐位按顺序传送的通讯方式称为串口通讯（简单来讲就是按顺序一位一位地传输数据）。
android线程开启线程的方法,Android 中三种启用线程的方法
weixin_36417642的博客
05-25 3400
在多线程编程这块，我们经常要使用Handler(处理)，Thread(线程)和Runnable这三个类，那么他们之间的关系你是否弄清楚了呢?首先说明Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。HandlerT...
Android 两种串口实现方法总结
qq_29443203的博客
01-29 2664
两种串口实现方法总结，请看： http://blog.csdn.net/fengyuwuzu0519/article/details/73928618   最近在做android串口的开发，找到一个开源的串口类android-serialport-api。其主页在这里http://code.google.com/p/android-serialport-api/  ，这里可以下到APK及对源码...
Android串口的使用
m0_37724690的博客
12-02 687
一、导入jar包 二、新建三个类 public class SerialPort { private static final String TAG = "SerialPort"; /* * Do not remove or rename the field mFd: it is used by native method close(); */...
2022-9-20----Android----User版 打开串口抓开机日志
qq_854189624的博客
09-20 1964
编译lk然后烧录lk，用串口抓取日志时不知道波特率的话可以查看。
Android串口操作，简化android-serialport-api的demo（附源码）
热门推荐
akunainiannian的专栏
03-30 5万+
最近在做android串口的开发，找到一个开源的串口类android-serialport-api。其主页在这里http://code.google.com/p/android-serialport-api/  ，这里可以下到APK及对源码。     但是下载源码之后发现源码不能直接使用，而且源码结构较为复杂。关于串口的操作不外乎几步：    1.打开串口（及配置串口）；    2.读串口；
通过串口实时打印Android内核调试log信息
风D追逐的专栏
06-24 9118
一、前言    在调试Android的Linux内核时，我们往往会通过打开对应模块的调试Log来查看一些关键信息。通常我们可以使用一些简单的查看方法，比如：    在pc端装有adb工具时，使用adb shell dmesg &gt;D:/Kernel.log     但是dmesg通常只能打印部分Log信息，如果连续输入命令，在保存的日志文件中可能会出现很多重复内容，这是因为dmesg会打印启动...
Android串口通信库源码：原生层实现与JAVA封装
综上所述，本文介绍了Android平台串口通信库源码所包含的核心知识，从原生层和JAVA层的实现到可能的文件组成，再到实际开发中的注意事项和应用场景。掌握这些知识点对于在Android平台上实现稳定高效的串口通信具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值