Android 监听wifi总结

最新推荐文章于 2023-08-31 14:08:48 发布
最新推荐文章于 2023-08-31 14:08:48 发布
阅读量3.9k 收藏 3
点赞数 1
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ajq1989/article/details/8891516
版权
这篇博客介绍了如何在Android中实现WiFi的开关控制以及连接特定WiFi的功能。通过提供的WiFi工具类，可以设置强制连接到指定的WiFi网络，即使设备之前已连接到其他网络。同时，文中提到了广播接收器的使用，以便监听WiFi状态的变化。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

功能实现：控制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

无线渗透之WiFi密码的监听
Allan的博客
08-03 6458
声明 本文章是审核家庭无线路由器安全性的教程，破解别人的无线路由器密码是违法的。 ​ 首先准备环境 无线网卡（推荐使用免驱的，我这里用的RT3070L） 虚拟机（如果是Windows环境需要虚拟机，我这里用的Vmware15Pro） 虚拟机镜像（可以是任意linux发行版，这里使用了cdlinux，因为集成了水滴，无需单独使用Aircrack-ng） EWSA（windows下的跑包软件，支持多显卡） 字典包（可以使用字典生成器自己按规则生成） .
android 监听wifi的连接状态,Android判断wifi状态 监听wifi连接
weixin_33321740的博客
05-26 2626
一、添加权限二、注册监听广播注册监听有两种方式1.AndroidMainfest.xml 中注册2.在代码中注册IntentFilter filter = new IntentFilter();filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);filter.addAction(WifiManager.WIFI_STATE_CHAN...
Android 监听 WiFi 开关状态
weixin_33709219的博客
04-27 172
Android 监听 WiFi 开关状态 转载请标明出处：http://blog.youkuaiyun.com/zhaoyanjun6/article/details/70854309 本文出自【赵彦军的博客】 WifiSwitch_Presenter 源码： package com.yiba.wifi.sdk.lib.pr...
android 监听wifi连接
谷粒的专栏
12-13 636
android 监听wifi成功连接上了一个热点： 代码第20行 public class WifiReceiver extends BroadcastReceiver{ @Override public void onReceive(Context context, Intent intent) { // TODO Auto-generated met
Android打开WLAN开关的广播状态监听
Widsom的博客
12-20 4567
Android打开WLAN开关的广播状态监听Android中WLAN的广播监听的是WLAN状态的改变 ，Action是WifiManager.WIFI_STATE_CHANGED_ACTION，WLAN的状态系统定义了5种，分别是WIFI_STATE_DISABLED WLAN已经关闭 WIFI_STATE_DISABLING WLAN正在关闭 WIFI_STATE_ENABLED
Android应用实时监听网络状态
WormholeStack
05-21 6375
在Android开发中我们肯定会遇到需要监听网络状态的时候，那我们应该怎么实现呢？ 老规矩先上效果图 实现思路，使用广播监听网络状态，接口回调展示状态。 首先我们需要用到的权限 <uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.RECORD_AUDIO" /> <!-- 读取网络信息状态 -->
Android中wifi与数据流量的切换监听详解
08-31
本文将详细讲解如何实现这一功能，特别是在监听WiFi与数据流量切换方面。 首先，我们需要了解两个关键的Android系统类：`ConnectivityManager`和`WifiManager`。`ConnectivityManager`是系统提供的用于管理网络连接...
Android 监听WiFi的开关状态实现代码
08-30
在Android开发中，监听WiFi的开关状态是一项基础但重要的功能。它允许应用程序根据设备的WiFi连接状态做出相应的响应，比如在WiFi打开时自动执行数据同步任务，或者在WiFi关闭时停止某些数据传输操作以节约电量和...
安卓wifi蓝牙相关-android获取wifi强度通过广播监听wifi信号强度的变化.zip
07-29
监听WiFi信号强度的变化通常通过注册一个`BroadcastReceiver`来实现。注册接收器时，需要指定`WifiManager.RSSI_CHANGED_ACTION`作为过滤器，这样当WiFi信号强度发生变化时，广播接收器就会接收到相应的广播。 4. ...
Android自动连接指定的wifi，免密码或指定密码
weixin_34220623的博客
07-02 1169
原文:Android自动连接指定的wifi，免密码或指定密码一、运行时的状态 遇到一个这样的要求：“不进行扫描操作，怎么对指定的免密码WIFI进行连接（之前没有连接过）”，于是动手写了一个Demo，如图所示未连接成功时的状态，第一个编辑框让用户输入SSID，第二个编辑框输入密码，密码可以根据实例情况输入，也可以不输入密码，因为有些Wifi免密码。这里的免密码不是指可以破解wifi密码。注意图片中...
WiFi开发 （二）Wifi热点
最新发布
chuyouyinghe的专栏
08-31 382
接着上一篇wifi的扫描连接等，这一篇主要说一下手机开启Wifi热点。demo的下载地址会在最下面贴出来。
Android 监听Wifi网络状态
yangjunjin的博客
09-02 2500
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开发之 WiFi广播监听
hzhdeine的博客
09-12 2830
安卓中关于系统开发的文章比较少, 对于刚刚接触做系统开发的开发者而言, 查阅资料是很难查阅到的. 最近做的开发项目中设计到了关于WiFi开发的问题, 刚开始是无从下手的, 对于监听系统的广播更是摸不着头绪; 小弟也是搞了许久, 才逐渐摸索出一些关于开发中需要监听的广播, 并抽空做了一点总结, 此文不定时更新: 一. 首先, 抛开所有其他的情况不说, 作为一个app, 我们需要监听当前是否有网
android.net.wifi的简单使用方法
热门推荐
liu149339750的专栏
09-19 3万+
获取Wifi的控制类WifiManager。  WifiManager  wm=(WifiManager)getSystemService(Context.WIFI_SERVICE); 接下来可以对wifi操作了，比如要打开、关闭wifi，可以通过WifiManager的setWifiEnabled（）方法来开关wifi。 若要查看一些信息，可以通过getConnectionInfo()方法
Android wifi同AP切换方案
weixin_43743963的博客
09-29 2043
Android wifi同AP切换方案
Android 根据账号和密码自动连接 WIFI （兼容Android 10）
梁超杰
04-15 5599
源码地址在这里在这里！！！！！ 面向谷歌搜索了很多博客，基本上都是失效的，只要你的compileSdkVersion版本高于28在Android 10设备上就无法连接wifi，虽然提示你是连接成功了但是实际上信号一直不可用。 解决办法目前只有这个: compileSdkVersion 28 buildToolsVersion "28.0.x" //可以是28.0.2 或者其他的 28下面的都可以 看下如何使用 package com.hello.wifi; import android.os.Bu
WIFI 简单的连接及常用密码破解
jinrumorijuesha的博客
03-19 5264
WIFI所需权限及配置 &amp;lt;uses-permission android:name=&quot;android.permission.INTERNET&quot; /&amp;gt; &amp;lt;uses-permission android:name=&quot;android.permission.CHANGE_WIFI_STATE&quot; /&amp;gt; &amp;lt;u
Android监听WIFI信号,这可能是Android上monitore Wifi信号强度的最佳方法
weixin_39812224的博客
05-26 428
对于那些想知道我是怎么做的人 . 我使用了Job Scheduler，因为它是一个需要 Build wifi连接的任务 .此外，您可以查看my blog，在那里您可以找到有关此信息和额外信息的更多详细信息最后，我得到了首先，声明每个活动的文本视图 .android:id="@+id/messageLogin"android:layout_width="match_parent"android:la...
Android wifi 连接上网
上孟的专栏
01-30 816
最近公司在做Wi-Fi连接上网，之间没做过这方面的东西，查了好多资料终于搞明白了一些东西，这里做一些记录，下面是我的Wi-Fi连接测试代码工具类，这里贴出来方便以后查阅，也希望能帮到一些遇到同样需求的小伙伴。 import android.net.wifi.WifiConfiguration; import android.net.wifi.WifiConfiguration.AuthAlg
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、付费专栏及课程。

余额充值