wifi断线重连

已于 2022-03-25 23:50:57 修改
阅读量268 收藏
点赞数
分类专栏： 网络通信 文章标签： c++
于 2022-03-25 23:48:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39518639/article/details/123748312
版权 
//WifiMgr.h
#pragma once
#include <windows.h>
#include <wlanapi.h>
#include <stdio.h>
#include <iostream>
#pragma comment(lib, "wlanapi.lib")

//连接方式
#define MODE_AUTO "auto"
#define MODE_MANUAL "manual"

//认证方式
#define AUTH_WPAPSK "WPAPSK"
#define AUTH_WPA2PSK "WPA2PSK"

//加密方式
#define ENCR_AES "AES"
#define ENCR_TKIP "TKIP"

/*WIFI信息*/
struct WIFIInfo {
	char account[64];

	char password[64];

	char mode[32];

	char auth[32];

	char encrypt[32];
};

class WifiMgr
{
public:
	WifiMgr();

	~WifiMgr();

	bool connect(const char* account, const char* password, const char* mode = MODE_MANUAL,
		const char* auth = AUTH_WPAPSK, const char* encrypt = ENCR_AES);

	bool connect(const WIFIInfo& info);

	bool reconnect();

	bool disconnect(bool removeProFile = true);

	bool connected();

	const char* getLastError();
protected:
	static void _stdcall wlanNotification(PWLAN_NOTIFICATION_DATA data, void* args);
private:
	bool m_connected = false;

	bool m_reconnect = false;

	char m_lastError[256] = { 0 };

	HANDLE m_handle = INVALID_HANDLE_VALUE;

	PWLAN_INTERFACE_INFO_LIST m_infoList = { 0 };

	WIFIInfo m_wifiInfo = { 0 };
};

//WifiMgr.cpp
#define _CRT_SECURE_NO_WARNINGS

#include "WifiMgr.h"


WifiMgr::WifiMgr()
{
}

WifiMgr::~WifiMgr()
{
	if (m_connected)
	{
		disconnect();
	}
}

bool WifiMgr::connect(const char* account, const char* password, const char* mode,
	const char* auth, const char* encrypt)
{
	bool result = false;
	do
	{
		if (!m_reconnect)
		{
			strcpy(m_wifiInfo.account, account);
			strcpy(m_wifiInfo.password, password);
			strcpy(m_wifiInfo.mode, mode);
			strcpy(m_wifiInfo.auth, auth);
			strcpy(m_wifiInfo.encrypt, encrypt);
		}

		unsigned long version = 0, value = 0;
		value = WlanOpenHandle(WLAN_API_VERSION, NULL, &version, &m_handle);
		if (value != ERROR_SUCCESS)
		{
			sprintf(m_lastError, "打开WIFI句柄失败,错误代码:%lu", value);
			break;
		}

		value = WlanEnumInterfaces(m_handle, NULL, &m_infoList);
		if (value != ERROR_SUCCESS)
		{
			sprintf(m_lastError, "枚举WIFI接口失败,错误代码:%lu", value);
			break;
		}

		char xmlBuffer[4096] = { 0 };
		sprintf(xmlBuffer, "<?xml version =\"1.0\"?>\
                             <WLANProfile xmlns =\"http://www.microsoft.com/networking/WLAN/profile/v1\">\
                             <name>%s</name>\
                             <SSIDConfig>\
                             <SSID>\
                             <name>%s</name>\
                             </SSID>\
                             </SSIDConfig>\
                             <connectionType>ESS</connectionType>\
                             <connectionMode>%s</connectionMode>\
                             <autoSwitch>false</autoSwitch>\
                             <MSM>\
                             <security>\
                             <authEncryption>\
                             <authentication>%s</authentication>\
                             <encryption>%s</encryption>\
                             <useOneX>false</useOneX>\
                             </authEncryption>\
                             <sharedKey>\
                             <keyType>passPhrase</keyType>\
                             <protected>false</protected>\
                             <keyMaterial>%s</keyMaterial>\
                             </sharedKey>\
                             </security>\
                             </MSM>\
                             </WLANProfile>",
			account, account, mode, auth, encrypt, password);

		wchar_t fileData[4096] = { 0 };
		int length = strlen(xmlBuffer);
		for (int j = 0; j < length; j++)
		{
			mbtowc(&fileData[j], &xmlBuffer[j], 1);
		}
		fileData[length] = '\0';

		WlanDisconnect(m_handle, &m_infoList->InterfaceInfo[0].InterfaceGuid, NULL);

		WLAN_REASON_CODE reasonCode = { 0 };
		value = WlanSetProfile(m_handle, &(m_infoList->InterfaceInfo[0].InterfaceGuid),
			0, fileData, NULL, TRUE, NULL, &reasonCode);
		if (value != ERROR_SUCCESS)
		{
			sprintf(m_lastError, "设置WIFI配置文件失败,错误代码:%lu", value);
			break;
		}

		wchar_t wideSsid[256] = { 0 };
		if (!MultiByteToWideChar(CP_ACP, 0, account, strlen(account) + 1,
			wideSsid, sizeof(wideSsid) / sizeof(wideSsid[0])))
		{
			sprintf(m_lastError, "多字符转宽字符失败,错误代码:%lu", GetLastError());
			break;
		}

		DOT11_SSID dot11Ssid = { 0 };
		memcpy(dot11Ssid.ucSSID, account, strlen(account) + 1);
		dot11Ssid.uSSIDLength = strlen(account);

		WLAN_CONNECTION_PARAMETERS connectionParameters;
		memset(&connectionParameters, 0, sizeof(connectionParameters));
		connectionParameters.pDot11Ssid = &dot11Ssid;
		connectionParameters.wlanConnectionMode = wlan_connection_mode_profile;
		connectionParameters.strProfile = wideSsid;   /* clear 可以填NULL */
		connectionParameters.dot11BssType = dot11_BSS_type_any;//dot11_BSS_type_independent;  /* msdn说可以dot11_BSS_type_any，实测不行 */
		connectionParameters.pDesiredBssidList = NULL;
		connectionParameters.dwFlags = 0; /* WLAN_CONNECTION_ADHOC_JOIN_ONLY */

		Sleep(300);

		value = WlanConnect(m_handle, &(m_infoList->InterfaceInfo[0].InterfaceGuid),
			&connectionParameters, NULL);
		if (value != ERROR_SUCCESS)
		{
			sprintf(m_lastError, "连接WIFI失败,错误代码:%lu", value);
			break;
		}

		value = WlanRegisterNotification(m_handle, WLAN_NOTIFICATION_SOURCE_ALL, false,
			wlanNotification, this, NULL, NULL);
		if (value != ERROR_SUCCESS)
		{
			sprintf(m_lastError, "注册通知失败,错误代码:%lu", value);
			break;
		}
		m_connected = true;
		result = true;
	} while (false);
	return result;
}

bool WifiMgr::connect(const WIFIInfo& info)
{
	return connect(info.account, info.password, info.mode, info.auth, info.encrypt);
}

bool WifiMgr::reconnect()
{
	bool result = false;
	m_reconnect = true;
	result = disconnect() && connect(m_wifiInfo);
	m_reconnect = false;
	return result;
}

bool WifiMgr::disconnect(bool removeProFile)
{
	bool result = true;
	do
	{
		wchar_t profile[256] = { 0 };
		if (!MultiByteToWideChar(CP_ACP, 0, m_wifiInfo.account, strlen(m_wifiInfo.account) + 1,
			profile, sizeof(profile) / sizeof(profile[0])))
		{
			sprintf(m_lastError, "多字符转宽字符失败,错误代码:%lu", GetLastError());
			break;
		}

		unsigned long value = 0;

		if (removeProFile)
		{
			value = WlanDeleteProfile(m_handle, &(m_infoList->InterfaceInfo->InterfaceGuid),
				profile, NULL);
			if (value != ERROR_SUCCESS)
			{
				sprintf(m_lastError, "删除WIFI配置文件%s失败,错误代码:%lu", m_wifiInfo.account, value);
				result = false;
			}
		}

		value = WlanDisconnect(m_handle, &(m_infoList->InterfaceInfo->InterfaceGuid), NULL);
		if (value != ERROR_SUCCESS)
		{
			if (strlen(m_lastError))
			{
				strcat(m_lastError, ",");
			}
			char temp[256] = { 0 };
			sprintf(temp, "断开WIFI失败,错误代码:%lu", value);
			strcat(m_lastError, temp);
			result = false;
		}

		if (m_handle != INVALID_HANDLE_VALUE)
		{
			WlanCloseHandle(m_handle, NULL);
			m_handle = INVALID_HANDLE_VALUE;
		}
		WlanFreeMemory(m_infoList);
		m_connected = false;
	} while (false);
	return result;
}

bool WifiMgr::connected()
{
	return m_connected;
}

const char* WifiMgr::getLastError()
{
	return m_lastError;
}

void WifiMgr::wlanNotification(PWLAN_NOTIFICATION_DATA data, void* args)
{
	WifiMgr* wifi = static_cast<WifiMgr*>(args);
	if (!wifi)
		return;

	unsigned long source = data->NotificationSource;
	unsigned long code = data->NotificationCode;
	unsigned long size = data->dwDataSize;
	const char* action = "unknown";
	if (source == WLAN_NOTIFICATION_SOURCE_ACM)
	{
		switch (source)
		{
		case wlan_notification_acm_start:
			action = "acm_start";
			break;
		case wlan_notification_acm_autoconf_enabled:
			action = "acm_autoconf_enabled";
			break;
		case wlan_notification_acm_autoconf_disabled:
			action = "acm_autoconf_disabled";
			break;
		case wlan_notification_acm_background_scan_enabled:
			action = "acm_background_scan_enabled";
			break;
		case wlan_notification_acm_background_scan_disabled:
			action = "acm_background_scan_disabled";
			break;
		case wlan_notification_acm_bss_type_change:
			action = "acm_bss_type_change";
			break;
		case wlan_notification_acm_power_setting_change:
			action = "acm_power_setting_change";
			break;
		case wlan_notification_acm_scan_complete:
			action = "acm_scan_complete";
			break;
		case wlan_notification_acm_scan_fail:
			action = "acm_scan_fail";
			break;
		case wlan_notification_acm_connection_start:
			action = "acm_connection_start";
			break;
		case wlan_notification_acm_connection_complete:
			action = "acm_connection_complete";
			break;
		case wlan_notification_acm_connection_attempt_fail:
			action = "acm_connection_attempt_fail";
			break;
		case wlan_notification_acm_filter_list_change:
			action = "acm_filter_list_change";
			break;
		case wlan_notification_acm_interface_arrival:
			action = "acm_interface_removal";
			break;
		case wlan_notification_acm_interface_removal:
			action = "acm_interface_removal";
			break;
		case wlan_notification_acm_profile_change:
			action = "acm_profile_change";
			break;
		case wlan_notification_acm_profile_name_change:
			action = "acm_profile_name_change";
			break;
		case wlan_notification_acm_profiles_exhausted:
			action = "acm_profiles_exhausted";
			break;
		case wlan_notification_acm_network_not_available:
			action = "acm_network_not_available";
			break;
		case wlan_notification_acm_network_available:
			action = "acm_network_available";
			break;
		case wlan_notification_acm_disconnecting:
			action = "acm_disconnecting";
			break;
		case wlan_notification_acm_disconnected:
			action = "acm_disconnected";
			break;
		case wlan_notification_acm_adhoc_network_state_change:
			action = "acm_adhoc_network_state_change";
			break;
		case wlan_notification_acm_end:
			action = "acm_end";
			break;
		default:break;
		}
	}
	else if (source == WLAN_NOTIFICATION_SOURCE_MSM)
	{
		switch (code)
		{
		case wlan_notification_msm_start:
			action = "msm_start";
			break;
		case wlan_notification_msm_associating:
		{
			auto ptr = ((PWLAN_MSM_NOTIFICATION_DATA)data->pData);
			std::cout << "ating reason:" << ptr->wlanReasonCode << std::endl;
		}
		action = "msm_associating";
		break;
		case wlan_notification_msm_associated:
		{
			auto ptr = ((PWLAN_MSM_NOTIFICATION_DATA)data->pData);
			std::cout << "ated reason:" << ptr->wlanReasonCode << std::endl;
		}
		action = "msm_associated";
		break;
		case wlan_notification_msm_authenticating:
		{
			auto ptr = ((PWLAN_MSM_NOTIFICATION_DATA)data->pData);
			std::cout << "auth reason:" << ptr->wlanReasonCode << std::endl;
		}
		action = "msm_authenticating";
		break;
		case wlan_notification_msm_connected:
			action = "msm_connected";
			break;
		case wlan_notification_msm_roaming_start:
			action = "msm_roaming_start";
			break;
		case wlan_notification_msm_roaming_end:
			action = "msm_roaming_end";
			break;
		case wlan_notification_msm_radio_state_change:
			action = "msm_radio_state_change";
			break;
		case wlan_notification_msm_signal_quality_change:
			action = "msm_signal_quality_change";
			printf("信号质量:%lu\n", *(unsigned long*)data->pData);
			break;
		case wlan_notification_msm_disassociating:
			action = "msm_disassociating";
			break;
		case wlan_notification_msm_disconnected:
		{
			auto ptr = ((PWLAN_MSM_NOTIFICATION_DATA)data->pData);
			std::cout << "dis reason:" << ptr->wlanReasonCode << std::endl;
		}
		action = "msm_disconnected";
		break;
		case wlan_notification_msm_peer_join:
			action = "msm_peer_join";
			break;
		case wlan_notification_msm_peer_leave:
			action = "msm_peer_leave";
			break;
		case wlan_notification_msm_adapter_removal:
			action = "msm_adapter_removal";
			break;
		case wlan_notification_msm_adapter_operation_mode_change:
			action = "msm_adapter_operation_mode_change";
			break;
		case wlan_notification_msm_end:
			action = "msm_end";
			break;
		default:break;
		}
	}
	printf("source %d,code %d,size %d,action %s\n", source, code, size, action);
	return;
}


//int main()
//{
//	std::cout << "base:" << WLAN_REASON_CODE_MSMSEC_KEY_SUCCESS_TIMEOUT << std::endl;
//	printf("sizeof %d,%d\n", sizeof(WLAN_CONNECTION_NOTIFICATION_DATA), sizeof(WLAN_MSM_NOTIFICATION_DATA));
//	WifiMgr mgr;
//	if (!mgr.connect("HONOR 9X PRO", "66666666"))
//	{
//		printf("连接wifi失败\n");
//	}
//	//Sleep(10000);
//	//printf("断开连接\n");
//	//mgr.disconnect();
//	//Sleep(10000);
//	getchar();
//	return 0;
//}

#include <Netlistmgr.h>
#include<iostream>
#include"WifiMgr.h"

bool checkIsNetwork() {
	bool bol = true; //是否联网,联网 true,不联网 false   
	CoInitialize(NULL);
	//  通过NLA接口获取网络状态
	IUnknown *pUnknown = NULL;
	HRESULT Result = CoCreateInstance(CLSID_NetworkListManager, NULL, CLSCTX_ALL, IID_IUnknown, (void **)&pUnknown);
	if (SUCCEEDED(Result))
	{
		INetworkListManager *pNetworkListManager = NULL;
		if (pUnknown)
			Result = pUnknown->QueryInterface(IID_INetworkListManager, (void **)&pNetworkListManager);
		if (SUCCEEDED(Result))
		{
			VARIANT_BOOL IsConnect = VARIANT_FALSE;
			if (pNetworkListManager)
				Result = pNetworkListManager->get_IsConnectedToInternet(&IsConnect);
			if (SUCCEEDED(Result))
			{
				bol = (IsConnect == VARIANT_TRUE) ? true : false;
			}
		}
		if (pNetworkListManager)
			pNetworkListManager->Release();
	}
	if (pUnknown)
		pUnknown->Release();
	CoUninitialize();
	return bol;
}

void main()
{
	bool result;
	while (true)
	{
		result=checkIsNetwork();
		if (result)
		{
			//printf("online\n");
		}
		else
		{

			std::cout << "base:" << WLAN_REASON_CODE_MSMSEC_KEY_SUCCESS_TIMEOUT << std::endl;
			printf("sizeof %d,%d\n", sizeof(WLAN_CONNECTION_NOTIFICATION_DATA), sizeof(WLAN_MSM_NOTIFICATION_DATA));

			printf("offline\n");
			WifiMgr mgr;
			if (!mgr.connect("网络名", "密码"))
			{
				printf("连接wifi失败\n");
			}
			Sleep(10000);

		}
	}
	
}
weixin_39518639
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现树莓派WiFi断线自动重连的实例代码
09-21
实现 WiFi 断线自动重连，原理是用 Python 监测网络是否断线，如果断线则重启网络服务。接下来给大家分享实现代码，需要的朋友参考下
C++ Windows下连接WIFI
qq_31629063的博客
01-29 3606
//WifiMgr.h #pragma once #include <windows.h> #include <wlanapi.h> #include <stdio.h> #include <iostream> #pragma comment(lib, "wlanapi.lib") //连接方式 #define MODE_AUTO "auto" #define MODE_MANUAL "manual" //认证方式 #defin...
C++连接Wlan/Wifi网络设备
老狼的专栏
02-28 3950
本单元只介绍如何链接wifi设备，对信号强度不做涉及，另外链接指定wifi之前应该先判断wifi是否已经链接，如果已经链接就没必要再链接了，代码中采用的是没做链接判断，先直接断开然后重新进行链接，代码如下： #include <wlanapi.h> #pragma comment(lib, "wlanapi.lib") BOOL connectWlan(CString Name, CString SSID, CString Password) { BOOL bRet = FALSE; D
WIFI DISCONNECT+CWJAP:3这个怎么解决吗大佬们！！
最新发布
weixin_71205273的博客
02-13 289
WIFI DISCONNECT +CWJAP:3
Android WiFi 经常掉线出现的几个原因分析！
热门推荐
一杯咖啡的专栏
03-23 2万+
原因１ ．从Log分析来看，这个是由于Dhcp request fail 导致最终disconnect . Log 分析如下： 16:53:31.659 958 6525 D NetUtils: dhcp_do_request failed : wlan0 (renew) 08-26 16:53:31.659 958 6525 E DhcpStateMachine: DHCPV4 f
wifidirect wifi-直连简单使用
Flybasker的博客
10-21 4781
请问文件中加相应的权限           package="alice.bw.com.wifidirectdemo">             android:name="android.permission.INTERNET"         android:required="true"/>             android:name="android.
C/C++语言实现WiFi（socket）数据收发（客户端和服务端）
XiaoCaiDaYong的博客
07-20 2269
C/C++语言实现WiFi（socket）数据收发（客户端和服务端） C/C++实现TCP通信、接收WIFI数据
ESP32 ESP32C3 Micropython 连接WIFI自动重连，连接阿里云物联网示例
06-02
WIFI可以自动短线重连。 阿里云物联网可以断线重连。 循环检查TOPIC消息。 WIFI和阿里云配置写在JSON文件，文件目录为setting文件夹。 包内包含ESP32和ESP32C3固件。
断网重连工具
02-15
断网重连工具支持teamviwer 满分必须是满分 远程办公首选
faaron-wifi断网自动重连2.0（附源码）
08-17
一个简单地wifi断网自动重连工具,开发环境为win8+vs2012，亲测win8下可以连接路由器和connectify。连接时请注意正确选择认证方式和加密方式。但是即使配置正确也有一定可能因为路由器问题无法连接。如果在连接失败后...
C++ 实现Windows WIFI管理器
A_water_的博客
01-03 692
出于项目需要，需要用C++开发一个wifi界面，实现wifi扫描、wifi连接与断开、wifi密码记住的基础功能。
android wifi断开原因分析
dailinqing1984的博客
05-21 1万+
最近在解bug的过程中经常遇到密码正确但处于saved的状态，总结原因有已下几种： 1 在ASSOCIATING阶段由于丢包导致ASSOC REJECT 03-16 09:22:12.440 D/WifiMonitor( 924): Event [IFNAME=wlan0 CTRL-EVENT-DISCONNECTED bssid=08:cc:68:9e:ac:20 reason=3
C++实现Wlan自动连接(wpa2 enterprise)
wwpp的博客
10-31 1624
网上大部分支持设置密码的文章都仅限于WPA2-个人，仅设置密码即可连接无线网。参考本文可实现WPA2企业(设置用户名密码才可上网)的代码自动连接。
C++实现的windows系统下的WIFI管理
Haitang_Zhang的博客
07-15 5225
最近项目中需要扫描和连接windows系统的WiFi无线热点，在网上CSDN了一些，发现基本上都是基于QT---Native Wifi functions 应用(WiFi有密码连接)这篇文章转来转去的，这篇文章比较笼统，大概就是API接口的链接放上去；考虑到WiFi管理功能在windows程序开发中遇到的机会较多，Native Wifi 的API接口在MSDN里都有，但是一些接口的使用以及状态的获取，没有一个总结性的说明，导致没办法短时间做出比较完整的WiFi管理功能。所以，我总结一套比较常用的wind..
调用windows系统动态库实现wifi连接及问题
Lost_Rabbit的博客
05-21 638
有个项目是c#做的， 有个需求是程序启动自动连接指定wifi，想到windows有个系统库支持，就用c++调的系统库，然后c#再调c++封装好的接口，比较简单，先上代码 c++动态库部分 静态调用的时候好像有问题，没细琢磨，就直接改用动态加载了 .h #pragma once #include <wlanapi.h> #pragma comment(lib,"wlanapi.lib") #pragma comment(lib,"ole32.lib") typedef int WINBOOL;
WiFi_Direct 直连开发实战
xianKOG的博客
06-30 2418
Wifi直连 开发 背景 近期有个项目，场景是 无网络情况下，实现一个手机与多个手机之间的交互。 采取的技术就是 wifi直连+socket通信 和 蓝牙连接+蓝牙通信。 这里只讲WiFi直连相关内容 WiFi直连 简介 WLAN 直连，最初称为Wi-Fi P2P（Peer-To-Peer），是Wi-Fi协议簇中的一个，使设备之间能够轻松连接彼此而不再需要一个中介性质的无线接入点（Access Point）。其使用范围从网页浏览到文件传输，以及同时与多个设备进行通信，能够充分发挥Wi-Fi的速度优势
c++ WlanAPI 承载网络 连接无线网络
d2262272d的博客
05-03 7650
最近在玩树莓派，烧录的也是win10  IOT 系统，然后想弄一个界面可以手动设置wifi热点，所以找了找windows的wlanAPI. 然后发现网上很多关于 保存了密码的无线网络 的连接方法，如：http://blog.csdn.net/lincyang/article/details/34430939这位仁兄的文章， 但是如何设置热点的几乎没有！ 所以只能自己弄，麻烦的
Ubuntu下WIFI不稳定问题
Jimmy的博客
08-22 4100
初步尝试 Ubuntu下无线网络总是不稳定，显示WIFI开着，密码也正确，但是连接时却一直连不上，显示一直connecting，建立WIFI连接时可以看到有如下syslog： Aug 15 20:00:25 ubuntu wpa_supplicant[1071]: wlp3s0: Authentication with ff:ea:da:e9:5a:3d timed out. Aug 15 20:00:25 ubuntu wpa_supplicant[1071]: wlp3s0: CTRL-EVENT-D
openwrt wifi 出现missing ACKs和deauthenticated due to inactivity 频繁掉线问题解决方案
wgl307293845的博客
11-19 3731
路由器出现频繁掉线问题 关键log1： Mon Dec 25 17:28:25 2017 daemon.info hostapd: wlan0: STA 00:00:00:00:00:00 IEEE 802.11: disconnected due to excessive missing ACKs Mon Dec 25 17:28:28 2017 daemon.info hostapd: wl...
linux wifi断线重连
09-14
在Linux中，你可以使用以下方法来断线重连WiFi： 1. 使用命令行工具（例如Network Manager）来管理WiFi连接。打开终端并输入以下命令： ``` nmcli d wifi off nmcli d wifi on ``` 这将关闭WiFi，然后重新打开以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值