Android 监听wifi总结

最新推荐文章于 2024-06-29 09:10:38 发布
最新推荐文章于 2024-06-29 09:10:38 发布
阅读量291 收藏
点赞数
分类专栏： 有关技术

功能实现：控制wifi开关，连上某个特定的wifi。

首先先上个wifi工具类，此类转载网上一人，出处不明了。 

package rodar.rgs.conference.utils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;

import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;

public class WifiConnect {
   WifiManager wifiManager;
      
  //定义几种加密方式，一种是WEP，一种是WPA，还有没有密码的情况
      public enum WifiCipherType
      {
    	  WIFICIPHER_WEP,WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
      }
    
  //构造函数
    public WifiConnect(WifiManager wifiManager)
    {
      this.wifiManager = wifiManager;
    }
    
  //打开wifi功能
       private boolean OpenWifi()
       {
      	 boolean bRet = true;
           if (!wifiManager.isWifiEnabled())
           {
         	  bRet = wifiManager.setWifiEnabled(true);  
           }
           return bRet;
       }
      
  //提供一个外部接口，传入要连接的无线网
       public boolean Connect(String SSID, String Password, WifiCipherType Type)
       {
          if(!this.OpenWifi())
      	{
      		 return false;
      	}
          System.out.println(">>>wifiCon=");
  //开启wifi功能需要一段时间(我在手机上测试一般需要1-3秒左右)，所以要等到wifi
  //状态变成WIFI_STATE_ENABLED的时候才能执行下面的语句
          while(wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING )
          {
          	 try{
       //为了避免程序一直while循环，让它睡个100毫秒在检测……
             	  Thread.currentThread();
          Thread.sleep(100);
             	}
             	catch(InterruptedException ie){
             }
          }
         
      WifiConfiguration wifiConfig = this.CreateWifiInfo(SSID, Password, Type);
      //
      	if(wifiConfig == null)
      {
      	       return false;
      }
          WifiConfiguration tempConfig = this.IsExsits(SSID);
          
          if(tempConfig != null)
          {
          	wifiManager.removeNetwork(tempConfig.networkId);
          }
          
//	        try {
//	        	//高级选项
//	        	String ip  ="192.168.1.201";
//	        	int networkPrefixLength =24;
//	        	InetAddress intetAddress  = InetAddress.getByName(ip);
//	        	int intIp = inetAddressToInt(intetAddress);  
//	        	String dns = (intIp & 0xFF ) + "." + ((intIp >> 8 ) & 0xFF) + "." + ((intIp >> 16 ) & 0xFF) + ".1";
//	        	setIpAssignment("STATIC", wifiConfig); //"STATIC" or "DHCP" for dynamic setting
//	        	setIpAddress(intetAddress, networkPrefixLength, wifiConfig);
//	        	setGateway(InetAddress.getByName(dns), wifiConfig);
//	        	setDNS(InetAddress.getByName(dns), wifiConfig);
//	        } catch (Exception e) {
//	        	// TODO: handle exception
//	        	e.printStackTrace();
//	        }
          
          int netID = wifiManager.addNetwork(wifiConfig);
      	boolean bRet = wifiManager.enableNetwork(netID, true); 
//	    	wifiManager.updateNetwork(wifiConfig);
      	
      	
      return bRet;
       }
       
      //查看以前是否也配置过这个网络
       private WifiConfiguration IsExsits(String SSID)
       {
      	 List<WifiConfiguration> existingConfigs = wifiManager.getConfiguredNetworks();
      	    for (WifiConfiguration existingConfig : existingConfigs) 
      	    {
      	      if (existingConfig.SSID.equals("\""+SSID+"\""))
      	      {
      	          return existingConfig;
      	      }
      	    }
      	 return null; 
       }
       
       private WifiConfiguration CreateWifiInfo(String SSID, String Password, WifiCipherType Type)
       {
       	WifiConfiguration config = new WifiConfiguration();
           config.allowedAuthAlgorithms.clear();
           config.allowedGroupCiphers.clear();
           config.allowedKeyManagement.clear();
           config.allowedPairwiseCiphers.clear();
           config.allowedProtocols.clear();
       	config.SSID = "\"" + SSID + "\"";  
       	if(Type == WifiCipherType.WIFICIPHER_NOPASS)
       	{
       		 config.wepKeys[0] = "";
       		 config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
       		 config.wepTxKeyIndex = 0;
       	}
       	if(Type == WifiCipherType.WIFICIPHER_WEP)
       	{
       		config.preSharedKey = "\""+Password+"\""; 
       		config.hiddenSSID = true;  
       	    config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
       	    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
       	    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
       	    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
       	    config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
       	    config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
       	    config.wepTxKeyIndex = 0;
       	}
       	if(Type == WifiCipherType.WIFICIPHER_WPA)
       	{
       	config.preSharedKey = "\""+Password+"\"";
       	config.hiddenSSID = true;  
       	config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);  
       	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);                        
       	config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);                        
       	config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);                   
          //config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);   
          config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP); 
          config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP); 
       	config.status = WifiConfiguration.Status.ENABLED;  
       	}
       	else
       	{
       		return null;
       	}
       	return config;
       }
       
       
       
       
       
       /***
        * Convert a IPv4 address from an InetAddress to an integer
        * @param inetAddr is an InetAddress corresponding to the IPv4 address
        * @return the IP address as an integer in network byte order
        */
       public static int inetAddressToInt(InetAddress inetAddr)
               throws IllegalArgumentException {
           byte [] addr = inetAddr.getAddress();
           if (addr.length != 4) {
               throw new IllegalArgumentException("Not an IPv4 address");
           }
           return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) |
                   ((addr[1] & 0xff) << 8) | (addr[0] & 0xff);
       }
       
   	public static void setIpAssignment(String assign, WifiConfiguration wifiConf)throws SecurityException, IllegalArgumentException,NoSuchFieldException, IllegalAccessException {
      setEnumField(wifiConf, assign, "ipAssignment");
    }
   	
    public static void setEnumField(Object obj, String value, String name) throws SecurityException, NoSuchFieldException,
    IllegalArgumentException, IllegalAccessException {
      Field f = obj.getClass().getField(name);
      f.set(obj, Enum.valueOf((Class<Enum>) f.getType(), value));
    }
    
    public static void setIpAddress(InetAddress addr, int prefixLength,WifiConfiguration wifiConf) throws SecurityException,IllegalArgumentException,
    NoSuchFieldException,IllegalAccessException, NoSuchMethodException,ClassNotFoundException, InstantiationException,InvocationTargetException {
      Object linkProperties = getField(wifiConf, "linkProperties");
      if (linkProperties == null)
        return;
      Class laClass = Class.forName("android.net.LinkAddress");
      Constructor laConstructor = laClass.getConstructor(new Class[] {InetAddress.class, int.class });
      Object linkAddress = laConstructor.newInstance(addr, prefixLength);
      ArrayList mLinkAddresses = (ArrayList) getDeclaredField(linkProperties,"mLinkAddresses");
      mLinkAddresses.clear();
      mLinkAddresses.add(linkAddress);
    }

    public static void setGateway(InetAddress gateway,WifiConfiguration wifiConf) throws SecurityException,IllegalArgumentException,
    NoSuchFieldException,IllegalAccessException, ClassNotFoundException,NoSuchMethodException, InstantiationException,InvocationTargetException {
      Object linkProperties = getField(wifiConf, "linkProperties");
      if (linkProperties == null)
        return;
      Class routeInfoClass = Class.forName("android.net.RouteInfo");
      Constructor routeInfoConstructor = routeInfoClass.getConstructor(new Class[] { InetAddress.class });
      Object routeInfo = routeInfoConstructor.newInstance(gateway);
      ArrayList mRoutes = (ArrayList) getDeclaredField(linkProperties,"mRoutes");
      mRoutes.clear();
      mRoutes.add(routeInfo);
    }

    public static void setDNS(InetAddress dns, WifiConfiguration wifiConf) throws SecurityException, IllegalArgumentException,NoSuchFieldException, IllegalAccessException {
      Object linkProperties = getField(wifiConf, "linkProperties");
      if (linkProperties == null)
        return;
      ArrayList<InetAddress> mDnses = (ArrayList<InetAddress>) getDeclaredField(linkProperties, "mDnses");
      mDnses.clear(); // or add a new dns address , here I just want to replace DNS1
      mDnses.add(dns);
    }
    
    public static Object getField(Object obj, String name) throws SecurityException, NoSuchFieldException,IllegalArgumentException, IllegalAccessException {
      Field f = obj.getClass().getField(name);
      Object out = f.get(obj);
      return out;
    }

    public static Object getDeclaredField(Object obj, String name) throws SecurityException, NoSuchFieldException,IllegalArgumentException, IllegalAccessException {
      Field f = obj.getClass().getDeclaredField(name);
      f.setAccessible(true);
      Object out = f.get(obj);
      return out;
    }
    
//	    public void editStaticWifiConfig(final ScanResult sr,String pwd, String ip, String gateway,int prefixLength,String dns) throws Exception{        
//	    	WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
//	    	
//	    	if(historyWifiConfig == null){
//	    		historyWifiConfig = createComWifiConfig(sr.SSID,pwd);
//	    		int netId = mWifiManager.addNetwork(historyWifiConfig);
//	    		mWifiManager.enableNetwork(netId, true);
//	    	}
//	    	
//	        setIpAssignment("STATIC", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
//	        setIpAddress(InetAddress.getByName(ip), prefixLength, historyWifiConfig);
//	        setGateway(InetAddress.getByName(gateway), historyWifiConfig);
//	        setDNS(InetAddress.getByName(dns), historyWifiConfig);
//	        
//	        mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
//		}
//	    
//	    public void editDhcpWifiConfig(final ScanResult sr,String pwd) throws Exception{        
//	    	WifiConfiguration historyWifiConfig = getHistoryWifiConfig(sr.SSID);
//	    	
//	    	if(historyWifiConfig == null){
//	    		historyWifiConfig = createComWifiConfig(sr.SSID,pwd);
//	    		int netId = mWifiManager.addNetwork(historyWifiConfig);
//	    		mWifiManager.enableNetwork(netId, true);
//	    	}
//	    	
//	        setIpAssignment("DHCP", historyWifiConfig); //"STATIC" or "DHCP" for dynamic setting
//	        
//	        mWifiManager.updateNetwork(historyWifiConfig); //apply the setting
//		}
}
类中注释高级选项处，是连接上wifi同时自己设定ip.记得wifiManager.updateNetwork(wifiConfig);

类中boolean bRet = wifiManager.enableNetwork(netID, true); 第二个参数true表示如果当前已经有连上一个wifi,要强制连到自己设定的wifi上，此参数必须为true否则连上的还是原来的wifi.

调用此类示例

WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
              WifiConnect wifi = new WifiConnect(wifiManager);
              wifi.Connect("wifiName", "wifipPassword",
                  WifiCipherType.WIFICIPHER_WPA);

需要的权限 
<uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
  

<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
<uses-permission android:name="android.permission.UPDATE_DEVICE_STATS" />
<uses-permission android:name="android.permission.WAKE_LOCK" />

如何在广播监听wifi的状态

广播接收类

package rodar.rgs.conference.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;

public class WifiStateReceiver extends BroadcastReceiver{

//	0 --> WIFI_STATE_DISABLING
//	1 --> WIFI_STATE_DISABLED
//	2 --> WIFI_STATE_ENABLING
//	3 --> WIFI_STATE_ENABLED
//	4 --> WIFI_STATE_UNKNOWN
  
  
  @Override
  public void onReceive(Context context, Intent intent) {
    // TODO Auto-generated method stub
    Bundle bundle = intent.getExtras();
        int oldInt = bundle.getInt("previous_wifi_state");
        int newInt = bundle.getInt("wifi_state");
        
        System.out.println(">>>oldInt="+oldInt+",newInt="+newInt);
//	      String oldStr = (oldInt>=0 && oldInt<WIFI_STATES.length) ?WIFI_STATES[oldInt] :"?";
//	      String newStr = (newInt>=0 && oldInt<WIFI_STATES.length) ?WIFI_STATES[newInt] :"?";
//	      Log.e("", "oldS="+oldStr+", newS="+newStr);
//	      if(newInt==WifiManager.WIFI_STATE_DISABLED || newInt==WifiManager.WIFI_STATE_ENABLED) {
//	         onWifiStateChange();  // define this function elsewhere!
//	      } else if(newInt==WifiManager.WIFI_STATE_DISABLING ||
//	                newInt==WifiManager.WIFI_STATE_ENABLING)
//	      {
	       chkbox_wifi.setText(newStr);
//	      } else {
//	       newStr += " (Is wpa_supplicant.conf readable?)";
	       chkbox_wifi.setText(newStr);
//	      }
        
    WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);
    WifiInfo info = wifiManager.getConnectionInfo();
    System.out.println(">>>onReceive.wifiInfo="+info.toString());
    System.out.println(">>>onReceive.SSID="+info.getSSID());
    
//		if(!info.getSSID().equals("Rodar")){
//			WifiConnect wifi = new WifiConnect(wifiManager);
//			wifi.Connect("Rodar", "rodar.5779858",
//					WifiCipherType.WIFICIPHER_WPA);	
//			System.out.println(">>>onReceive.SSID1="+info.getSSID());
//		}
    
    
     if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction()))
         {
             Parcelable parcelableExtra = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
             if (null != parcelableExtra)
             {
                 NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                 switch (networkInfo.getState())
                 {
                 case CONNECTED:
                     Log.e("APActivity", "CONNECTED");
                     break;
                 case CONNECTING:
                     Log.e("APActivity", "CONNECTING");
                     break;
                 case DISCONNECTED:
                     Log.e("APActivity", "DISCONNECTED");
                     break;
                 case DISCONNECTING:
                     Log.e("APActivity", "DISCONNECTING");
                     break;
                 case SUSPENDED:
                     Log.e("APActivity", "SUSPENDED");
                     break;
                 case UNKNOWN:
                     Log.e("APActivity", "UNKNOWN");
                     break;
                 default:
                     break;
                 }
             }
         }


  }
  
  
  
//	// 显示Wifi状态以及ip地址:
//	public static String StringizeIp(int ip) {
//	  int ip4 = (ip>>24) & 0x000000FF;
//	  int ip3 = (ip>>16) & 0x000000FF;
//	  int ip2 = (ip>> 8 )& 0x000000FF;
//	  int ip1 = ip       & 0x000000FF;
//	  return Integer.toString(ip1) + "." + ip2 + "." + ip3 + "." + ip4;
//	}
//	private void onWifiStateChange() {
//	         String ip_str = "";
//	         WifiInfo info = mMainWifi.getConnectionInfo();
//	         if(info != null) {
//	          int ipaddr = info.getIpAddress();
//	          ip_str = " (ip="+StringizeIp(ipaddr)+")";
//	         }
//	        
//	        if(mMainWifi.isWifiEnabled()==true)
//	               chkbox_wifi.setText("Wifi is on [" + ip_str + "]");
//	        else
//	               chkbox_wifi.setText("Wifi is off");
//	        
//	}
}

注册和取消广播一般在onstart和onstop里 
WifiStateReceiver wifiStateReceiver;
  @Override
  protected void onStart() {
    //注册网络监听
    wifiStateReceiver = new WifiStateReceiver();
    IntentFilter filter = new IntentFilter();
    filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
    filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
    registerReceiver(wifiStateReceiver, filter);
    
    super.onStart();
  }

  @Override
  protected void onStop() {
    //注销网络监听
    unregisterReceiver(wifiStateReceiver);
    super.onStop();
  }

关于广播监控wifi开关还是连接状态可以看这个连接 http://www.cnblogs.com/wanghafan/archive/2013/01/10/2855096.html
老金的杂货铺
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android设备中实现wifi状态监听
D13469967652的博客
03-05 3155
一、目标 APP中实现监听Android设备（手机、TV或其他设备）已连接的wifi的状态信息，并定时上传至服务器，用于分析特定时间点设备所在环境中wifi的状态及信号强度。 二、使用场景 多个智能WiFi设备组成的实际场景中，设备偶尔出现了控制失败的情况，需结合场景中当时的wifi状态及信号强度，分析设备控制失败的原因。故希望通过场景中的某个Android设备上安装此APP，监听wifi状态信息...
Android 监听WIFI
weixin_30555125的博客
01-10 90
[一篮饭特稀原创，转载请注明出自http://www.cnblogs.com/wanghafan/archive/2013/01/10/2855096.html] 1.注册一个广播接收器，监听网络状态 1 private void Start() 2 { 3 IntentFilter filter = new IntentFilter(); 4 ...
Android Wi-Fi 感知
最新发布
华南烹鱼宴
06-29 863
通过 Android 8.0 中新增的功能，支持设备可以直接使用 Wi-Fi 感知协议发现其他设备、与其他设备互连，以及将覆盖范围扩展到其他设备（Android 9 中新增的功能），而无需连接到互联网或移动网络。此功能是基于(WFA)（2.0 版、3.0 版和 3.1 版）构建的，它支持在断开网络的情况下，在可信设备与应用之间轻松共享高吞吐量数据。
Android 监听wifi广播的两种方式
阳光雨露
11-06 330
package com.comit.broadcast; import com.comit.util.AppHpler; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.net.Conne...
android 监听wifi连接
谷粒的专栏
12-13 596
android 监听wifi成功连接上了一个热点： 代码第20行 public class WifiReceiver extends BroadcastReceiver{ @Override public void onReceive(Context context, Intent intent) { // TODO Auto-generated met
[Android] 监听WiFi状态
qq_67317876的博客
11-28 927
在Android开发中实现对WiFi开启、关闭以及切换的监听
Android WiFi热点监听
qq_46290634的博客
07-20 814
1、注册广播，使用广播监听WiFi热点状态 IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction("android.net.wifi.WIFI_AP_STATE_CHANGED"); registerReceiver(new HotsspotReceiver(), intentFilter); 2、创建广播进行监听状态 class HotsspotReceiver extends
android 监听wifi的连接状态,Android判断wifi状态 监听wifi连接
weixin_33321740的博客
05-26 2497
一、添加权限二、注册监听广播注册监听有两种方式1.AndroidMainfest.xml 中注册2.在代码中注册IntentFilter filter = new IntentFilter();filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);filter.addAction(WifiManager.WIFI_STATE_CHAN...
Android中wifi与数据流量的切换监听详解
08-31
本文将详细讲解如何实现这一功能，特别是在监听WiFi与数据流量切换方面。 首先，我们需要了解两个关键的Android系统类：`ConnectivityManager`和`WifiManager`。`ConnectivityManager`是系统提供的用于管理网络连接...
安卓wifi蓝牙相关-android获取wifi强度通过广播监听wifi信号强度的变化.zip
07-29
监听WiFi信号强度的变化通常通过注册一个`BroadcastReceiver`来实现。注册接收器时，需要指定`WifiManager.RSSI_CHANGED_ACTION`作为过滤器，这样当WiFi信号强度发生变化时，广播接收器就会接收到相应的广播。 4. ...
安卓 监听网络及WIFI状态Demo
04-05
在安卓APP中嵌入网络状态监听事件，包括连接、断开、SSID名称、信号强度、连接速度等信息，详见Demo中Log信息
Android 监听WiFi的开关状态实现代码
08-30
主要介绍了Android 监听WiFi的开关状态实现代码的相关资料,需要的朋友可以参考下
WIFI连接状态监听
07-08
实现WIFI状态的监听，开启关闭的控制，扫描周围wifi以及获取本机连接过的wifi
Android 监听Wifi网络状态
yangjunjin的博客
09-02 2328
1、权限 <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" /> <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /&g
Android监控wifi连接状态
weixin_34194702的博客
05-29 271
在项目中我们经常有这样的需求，在下载图片或其他文件时会遇到网络不稳定的问题，导致下载失败等，因此， 监控网络连接的状态尤为重要，最近我做的一个项目主要依靠连接wifi来下载，因此就整理了一些用来监控wifi状态的小demo 第一步：首先在Activity中注册一个监控wifi状态的广播 1 package com.front.wifi_action; 2 3 impor...
android 监听wifi的连接状态,android广播监控wifi连接状态
weixin_39779975的博客
05-26 248
package com.example.floatdialogtest;import android.content.BroadcastReceiver;import android.content.Context;import android.content.Intent;import android.net.NetworkInfo;import android.net.wifi.WifiInf...
Android监听WIFI信号,这可能是Android上monitore Wifi信号强度的最佳方法
weixin_39812224的博客
05-26 378
对于那些想知道我是怎么做的人 . 我使用了Job Scheduler，因为它是一个需要 Build wifi连接的任务 .此外，您可以查看my blog，在那里您可以找到有关此信息和额外信息的更多详细信息最后，我得到了首先，声明每个活动的文本视图 .android:id="@+id/messageLogin"android:layout_width="match_parent"android:la...
android 监听wifi状态
06-01
要监听 Android 设备的 WiFi 状态，可以使用以下代码： 首先，在 AndroidManifest.xml 文件中添加以下权限： ```xml <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> <uses-permission ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值