wifi自动连接指定热点

最新推荐文章于 2022-02-24 15:27:55 发布
最新推荐文章于 2022-02-24 15:27:55 发布
阅读量476 收藏 1
点赞数
分类专栏： android 文章标签： wifi连接 自动连接WIFI 连接指定WIFI热点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kanwode111/article/details/40148729
版权

首先，我是参考的这里面的内容，然后就没有新做wifi工具类：http://blog.csdn.net/yuanbohx/article/details/8109042

主要说一下我的处理，声明一个重点:

WifiManager.WIFI_STATE_CHANGED_ACTION

这个消息只有当WIFI网络打开或者关闭（以及两者的进行时，才会广播该事件，而WIFI的打开，与你程序连没连上WIFI，是完全不同的两个概念），wifi状态有五个，只说四个:WIFI_STATE_DISABLED 已经关闭, WIFI_STATE_DISABLING正在关闭， WIFI_STATE_ENABLED已经打开, WIFI_STATE_ENABLING正在打开

而你如果想判断你的WIFI，有没有连到指定的热点上，需要另外注册一个事件，当然有人用

wifianager.getConnectionInfo().getSupplicantState() ==SupplicantState.COMPLETED)

不知道为什么我用这种方式得到的从来都没有是过COMPLETED，所有，我注册了另外一个过滤器，过滤的是ConnectivityManager.CONNECTIVITY_ACTION

public class MainActivity extends Activity {
	
	private TextView showWifi;
	
	private Button connectWifi;
	
	private Button disconnectWifi;
	
	private Button closeWifi;
	
	WifiAdmin wifi;
	
	private String ssid = "lxkf0001";
	private String password = "lxdz8888";
	
	private static final int DISCONNECT_WIFI = 0;
	
	
	/**
	 * WIFI连接处理
	 */
	Handler wifiHandler = new Handler() {
		public void handleMessage(Message msg) {
			switch (msg.what){
			case DISCONNECT_WIFI:
				// 扫描WIFI热点
				wifi.startScan();
				
				// 判断是否能扫描到指定的WIFI
		    	ScanResult scanWifi = wifi.isExistWifi(ssid);
		    	if(scanWifi == null) {
		    		showWifi.setText("扫描不到指定的WIFI---------------------------------");
		    		break;
		    	}
		    	
		    	// 创建新的WIFIconfig
		    	WifiConfiguration config = wifi.isExistWifiConfig(ssid);
		    	
		    	int networkId = -1;
		    	
		    	if(config == null) {
		    		config = wifi.createWifiInfo(ssid, password, 3);
		    		networkId = wifi.addNetwork(config);
		    	} 
		    	
		    	showWifi.setText("WIFI开始连接---------------------------------");
		    	
		    	//判断WIFI是否连接，如果连接是否为指定的WIFI
		    	if(wifi.getmWifiInfo() == null) { 
		    		wifi.connectWifi(config.networkId);
		    		
		    	} else {
		    		String connectedSSID = wifi.getmWifiInfo().getSSID();
		    		if(connectedSSID.equals(ssid)) break;
	    			// 如果连接的WIFI，不是指定的热点，断�?��接，重新进行连接
	    			wifi.disconnectWifi(wifi.getmWifiInfo().getNetworkId());
	    			if(networkId != -1){
	    				wifi.connectWifi(networkId);
	    			} else {
	    				wifi.connectWifi(config.networkId);
	    			}
		    		
		    	}
		    	wifi.setmWifiInfo(wifi.getmWifiManager().getConnectionInfo());
			}
			
		}
	};
	
	
	/**
	 * 用来监听WIFI连接的打开和关闭
	 */
	private BroadcastReceiver receiver = new BroadcastReceiver(){

		@Override
		public void onReceive(Context context, Intent intent) {
			switch( intent.getAction()) {
			case WifiManager.WIFI_STATE_CHANGED_ACTION:
				switch(wifi.checkState()) {
				case WifiManager.WIFI_STATE_DISABLED:
					showWifi.setText("WIFI已经关闭");
					wifi.openWifi();
					break;
				case WifiManager.WIFI_STATE_DISABLING:
					showWifi.setText("WIFI正在关闭");
					break;
				case WifiManager.WIFI_STATE_ENABLING:
					showWifi.setText("WIFI正在打开");
					break;
				case WifiManager.WIFI_STATE_ENABLED:
					showWifi.setText("WIFI打开成功");
					wifiHandler.sendEmptyMessage(DISCONNECT_WIFI);
					break;
				}
			}
		}
		
	};
	
	/**
	 * 用来监听WIFI是否连接
	 */
	BroadcastReceiver wifiIsConnected = new BroadcastReceiver(){
		@Override
		public void onReceive(Context context, Intent intent) {
			if(intent.getAction().equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
				ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);  
		        if (cm == null) return;  
	            NetworkInfo networkInfo = cm.getActiveNetworkInfo();  
	            if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {  
	            	showWifi.setText("WIFI连接成功---------------------------------");
	            	//  如果连接的wifi和指定的wifi不一样，则重新进行连接
	            	if(!wifi.getmWifiInfo().getSSID().equals(ssid)) {
	            		wifi.disconnectWifi(wifi.getmWifiInfo().getNetworkId());
	            		wifiHandler.sendEmptyMessage(DISCONNECT_WIFI);
	            	}
	            }  
			}
		}
	};
	
	
	
	IntentFilter filter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION);
	
	IntentFilter wifiConnected = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		wifi = new WifiAdmin(this);
		init();
		registerReceiver(receiver, filter);
		registerReceiver(wifiIsConnected, wifiConnected);
	}
	
	private void init() {
		showWifi = (TextView) findViewById(R.id.showWifi);
		connectWifi = (Button) findViewById(R.id.connectWifi);
		connectWifi.setOnClickListener(new View.OnClickListener() {
			
			@Override
			public void onClick(View v) {
				if(wifi == null) wifi = new WifiAdmin(MainActivity.this);
				wifi.openWifi();
			}
		});
		
		disconnectWifi = (Button)findViewById(R.id.disconnectWifi);
		disconnectWifi.setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				WifiInfo scan = wifi.getmWifiInfo();
				if(scan != null) {
					showWifi.setText(" WIFI不存在" + wifi.checkState());
					wifi.disconnectWifi(scan.getNetworkId());
					wifiHandler.sendEmptyMessage(DISCONNECT_WIFI);
				}
			}
		});
		
		closeWifi = (Button) findViewById(R.id.closeWifi);
		closeWifi.setOnClickListener(new View.OnClickListener() {
			
			@Override
			public void onClick(View v) {
				wifi.closeWifi();
			}
		});
	}


}


我写的代码比较乱，但功能能实现，然后用到的工具类，就是顶上链接里面直接粘过来的，我也贴上

public class WifiAdmin { 
    // 定义WifiManager对象  
    private WifiManager wifiManager; 
    // 定义WifiInfo对象  
    private WifiInfo wifiInfo; 
    // 扫描出的网络连接列表  
    private List<ScanResult> wifiList; 
    // 网络连接列表  
    private List<WifiConfiguration> wifiConfiguration; 
    // 定义一个WifiLock  
    WifiLock mWifiLock; 
    
    /**
     * 没有加密
     */
    public static final int WIFI_NO_PASSWORD = 1;
    
    /**
     * WEP 加密
     */
    public static final int WIFI_PASSWORD_WEP = 2;
    
    /**
     * WPA 加密 
     */
    public static final int WIFI_PASSWORD_WPA = 3;

 
    // 构造器  
    public WifiAdmin(Context context) { 
        // 取得WifiManager对象  
        wifiManager = (WifiManager) context 
                .getSystemService(Context.WIFI_SERVICE); 
        // 取得WifiInfo对象  
        wifiInfo = wifiManager.getConnectionInfo(); 
    } 
 
    // 打开WIFI  
    public void openWifi() { 
        if (!wifiManager.isWifiEnabled()) { 
            wifiManager.setWifiEnabled(true); 
        } 
    } 
 
    // 关闭WIFI  
    public void closeWifi() { 
        if (wifiManager.isWifiEnabled()) { 
            wifiManager.setWifiEnabled(false); 
        } 
    } 
 
    // 检查当前WIFI状态  
    public int checkState() { 
        return wifiManager.getWifiState(); 
    } 
 
    // 锁定WifiLock  
    public void acquireWifiLock() { 
        mWifiLock.acquire(); 
    } 
 
    // 解锁WifiLock  
    public void releaseWifiLock() { 
        // 判断时候锁定  
        if (mWifiLock.isHeld()) { 
            mWifiLock.acquire(); 
        } 
    } 
 
    // 创建一个WifiLock  
    public void creatWifiLock() { 
        mWifiLock = wifiManager.createWifiLock("Test"); 
    } 
 
    // 得到配置好的网络  
    public List<WifiConfiguration> getConfiguration() { 
        return wifiConfiguration; 
    } 
 
    // 指定配置好的网络进行连接  
    public void connectConfiguration(int index) { 
        // 索引大于配置好的网络索引返回  
        if (index > wifiConfiguration.size()) { 
            return; 
        } 
        // 连接配置好的指定ID的网络  
        wifiManager.enableNetwork(wifiConfiguration.get(index).networkId, 
                true); 
    } 
 
    public void startScan() { 
        wifiManager.startScan(); 
        // 得到扫描结果  
        wifiList = wifiManager.getScanResults(); 
        // 得到配置好的网络连接  
        wifiConfiguration = wifiManager.getConfiguredNetworks(); 
    } 
 
    // 得到网络列表  
    public List<ScanResult> getWifiList() { 
        return wifiList; 
    } 
 
    // 查看扫描结果  
    public StringBuilder lookUpScan() { 
        StringBuilder stringBuilder = new StringBuilder(); 
        for (int i = 0; i < wifiList.size(); i++) { 
            stringBuilder 
                    .append("Index_" + new Integer(i + 1).toString() + ":"); 
            // 将ScanResult信息转换成一个字符串包  
            // 其中把包括：BSSID、SSID、capabilities、frequency、level  
            stringBuilder.append((wifiList.get(i)).toString()); 
            stringBuilder.append("/n"); 
        } 
        return stringBuilder; 
    }
 
    // 得到MAC地址  
    public String getMacAddress() { 
        return (wifiInfo == null) ? "NULL" : wifiInfo.getMacAddress(); 
    } 
 
    // 得到接入点的BSSID  
    public String getBSSID() { 
        return (wifiInfo == null) ? "NULL" : wifiInfo.getBSSID(); 
    } 
    
    /**
     * 得到SSID
     * @return
     */
    public String getSSID() {
    	return (wifiInfo == null) ? "NULL" : wifiInfo.getSSID(); 
    }
 
    // 得到IP地址  
    public int getIPAddress() { 
        return (wifiInfo == null) ? 0 : wifiInfo.getIpAddress(); 
    } 
 
    // 得到连接的ID  
    public int getNetworkId() { 
        return (wifiInfo == null) ? 0 : wifiInfo.getNetworkId(); 
    } 
 
    // 得到WifiInfo的所有信息包  
    public String getWifiInfo() { 
        return (wifiInfo == null) ? "NULL" : wifiInfo.toString(); 
    } 
 
    // 添加一个网络并连接  
    public void addNetwork(WifiConfiguration wcg) { 
	 int wcgID = wifiManager.addNetwork(wcg); 
     boolean b =  wifiManager.enableNetwork(wcgID, true); 
     System.out.println("a--" + wcgID);
     System.out.println("b--" + b);
    } 
 
    // 断开指定ID的网络  
    public void disconnectWifi(int netId) { 
        wifiManager.disableNetwork(netId); 
        wifiManager.disconnect(); 
    } 
    
    /**
     * 连接到指定的网络
     * @param netId
     */
    public void connectWifi(int netId) {
    	wifiManager.enableNetwork(netId, true);
    }
 
    //然后是一个实际应用方法，只验证过没有密码的情况：
 
    /**
     * 分为三种情况：1没有密码2用wep加密3用wpa加密
     * @param SSID
     * @param Password
     * @param Type
     * @return
     */
    public WifiConfiguration createWifiInfo(String SSID, String Password, int Type) 
    { 
          WifiConfiguration config = new WifiConfiguration();   
           config.allowedAuthAlgorithms.clear(); 
           config.allowedGroupCiphers.clear(); 
           config.allowedKeyManagement.clear(); 
           config.allowedPairwiseCiphers.clear(); 
           config.allowedProtocols.clear(); 
          config.SSID = "\"" + SSID + "\"";   
          
          WifiConfiguration tempConfig = this.isExistWifiConfig(SSID);           
          if(tempConfig != null) {  
        	  wifiManager.removeNetwork(tempConfig.networkId);  
          }
          
          if(Type == 1) //WIFICIPHER_NOPASS
          { 
               config.wepKeys[0] = ""; 
               config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE); 
               config.wepTxKeyIndex = 0; 
          } 
          if(Type == 2) //WIFICIPHER_WEP
          { 
              config.hiddenSSID = true;
              config.wepKeys[0]= "\""+Password+"\""; 
              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 == 3) //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;   
          }
           return config; 
    } 
    
    /**
     * 是否存在指定的SSID，的WIFIConfig
     * @param SSID
     * @return
     */
    private WifiConfiguration isExistWifiConfig(String SSID)  
    {  
        List<WifiConfiguration> existingConfigs = wifiManager.getConfiguredNetworks();  
           for (WifiConfiguration existingConfig : existingConfigs)   
           {  
             if (existingConfig.SSID.equals("\""+SSID+"\""))  
             {  
                 return existingConfig;  
             }  
           }  
        return null;   
    }
    
    /**
     * 是否能扫描到指定的WIFI
     * @param SSID
     * @return
     */
    private ScanResult isExistWifi(String SSID) {
    	if(this.wifiList == null || this.wifiList.size() == 0) this.startScan();
    	for(ScanResult scan : this.wifiList) {
    		if(scan.SSID.equals(SSID)) return scan;
    	}
    	return null;
    }
    
    /**
     * 连接到指定WIIF
     * @param SSID
     * @param Password
     * @param Type
     */
    public void connectWifi(String SSID, String Password, int Type) throws ExceptionUtils{
    	// 判断WIFI是否打开, 如果没有打开，则打开它
    	this.openWifi();
    	
    	//判断当前WIFI列表是否为空，如果为空则重新进行扫描
    	if(this.wifiList == null || this.wifiList.size() == 0) {
    		this.startScan();
    	}
    	
    	// 判断是否能扫描到指定的WIFI
    	ScanResult scanWifi = this.isExistWifi(SSID);
    	if(scanWifi == null) {
    		throw new ExceptionUtils(0, "扫描不到指定的WIFI");
    	}
    	
    	// 创建新的WIFIconfig
    	WifiConfiguration config = this.isExistWifiConfig(SSID);
    	
    	
    	if(config == null) {
    		config = this.createWifiInfo(SSID, Password, Type);
    		wifiManager.addNetwork(config);
    	} 
    	
    	//判断WIFI是否连接，如果连接是否为指定的WIFI
    	if(this.wifiInfo == null) { 
    		this.connectWifi(config.networkId);
    	} else {
    		String connectedSSID = this.wifiInfo.getSSID();
    		if(!connectedSSID.equals(SSID)) {
    			// 如果连接的WIFI，不是指定的热点，断开连接，重新进行连接
    			this.disconnectWifi(this.wifiInfo.getNetworkId());
    			this.connectWifi(config.networkId);
    		}
    	}
    }
  
}
//

代码等审核通过之后再传上下载区

kanwode111
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Delphi xe vcl WIFI扫描源码.rar
07-10
Delphi xe vcl WIFI扫描源码，是一个Wifi扫描器程序的源代码，需要运行本程序的电脑中安装有硬件实体Wifi扫描硬件，本程序相当于驱动软件，用于扫描在范围的Wifi路由器。程序源代码较多，原型程序来自于国外，运行界面效果请参见测试截图示。
android 指定wifi热点自动连接
04-22
在Android平台上，实现指定WiFi热点自动连接是一项涉及网络管理和设备自动化功能的技术。这一特性对于许多应用，特别是那些依赖稳定网络连接的应用，如智能家居控制、远程监控等，具有重要意义。以下将详细阐述如何...
Delphi XE 获取Wifi 信息
jeff_wdj的专栏
06-18 3201
unit iOrder.Android.Wifi; interface uses   System.SysUtils,   System.Classes,   Androidapi.JNI.GraphicsContentViewText,   Androidapi.JNIBridge,   Androidapi.JNI.Telephony,   Androidapi
Detecting Wifi Networks Using Delphi and Native Wifi API
阳光小飞鱼's Blog
03-20 1691
{$APPTYPE CONSOLE}   uses   Windows,   SysUtils,   nduWlanAPI   in 'nduWlanAPI.pas',   nduWlanTypes in 'nduWlanTypes.pas';   function DOT11_AUTH_ALGORITHM_To_String( Dummy :Tndu_DOT11_AUTH_
Delphi在Android下通过WiFI进行调试
weixin_30823001的博客
09-18 92
如果我们需要调试USB程序且Android设备只有一个USB口，那么可以通过WiFi来调试程序，这样USB口就可以用了。 大致步骤如下： 1.在有root权限的Android设备里安装“Wifi ADB无线调试器” 2.通过“Wifi ADB无线调试器”,设置好端口，启动WiFi ADB，假设Android设备IP为192.168.1.109,端口为5555 3.在Windows下运行CM...
单片机---ESP8266Wifi SmartConfig一键配置（一）
小人物的编程
02-24 6035
介绍了ESP8266的一键联网功能
开机自动连接指定名称wifi热点
09-10
在Android系统中，实现“开机自动连接指定名称的WiFi热点”功能涉及到多个技术层面，尤其在Amlogic这样的特定环境下编译时，需要注意更多的细节。以下将详细解释这一过程中的关键知识点。 1. **Android系统服务**：...
Android 判断是否连接成功了指定wifi
08-30
总结一下，Android判断是否连接成功了指定Wi-Fi的方法主要包括使用反射调用隐藏的`WifiInfo.getMeteredHint()`方法，结合`WifiInfo.getSSID()`和`WifiManager.isConnected()`。在实际开发中，确保对反射操作进行充分...
C#连接指定的WIFI
04-03
针对题目中的【标题】"C#连接指定的WIFI"，我们可以深入探讨如何使用C#来管理和连接无线网络，特别是在Windows操作系统环境下。这个主题涉及到.NET框架、C#编程以及Windows API调用。 【描述】中提到的“NativeWifi...
python自动连接热点自动注销热点.rar
02-24
在这个特定的场景中，"python自动连接热点自动注销热点.rar" 提供的可能是用于自动连接和断开Wi-Fi热点的Python脚本。这个脚本可以帮助用户在需要时快速、便捷地进行网络连接和断开，比如在移动设备或笔记本电脑上。...
WiFi扫描程序Delphi版源码..rar
05-04
WiFi扫描程序Delphi版源码..rar
Delphi FMX 获取安卓WIFI信息并实现UDP通信
03-14
Delphi FMX 获取安卓WIFI本机的IP信息 手机通过UDP与终端通信，实现发送数据（按协议发送，可以达到控制硬件产品的目的）
delphi开发的自动判断无线ap是否在线并自动登录修改指定参数的工具
07-13
delphi开发的自动判断无线ap是否在线，并自动登录修改指定参数的工具。
delphi写wifi必须的几个源代码
08-21
delphi写wifi必须的几个源代码文件，上传搞掂资源分
WlanAPI_wlanapi_wifi_delphiwifescaner_
10-03
Scaned to wifi in delphi source
WiFi扫描程序Delphi版
05-07
摘要:Delphi源码,网络相关,WiFi　　Delphi Wifi连接扫描程序，扫描当前可用的WiFi连接，使用无线路由的朋友会更清楚这一点。
使用WIFIMAN.DLL动态库结合Delphi实现Windows无线管理器。
青草 绿叶 百合
09-17 3885
去年的时候，公司让我做一个windows的无线管理器，那时候还是个愣头青，后来辗转找到了一个WIFI管理的DLL库——WiFi-Manager。 　　这个国外的库对windows的Wifi管理已经封装成了若干种方法，支持delphi和VS/VC以动态库的方式加载和使用它，官方给的DEMO也相当完整。当然，它是收费的。我偶然间得到了已经购买的DLL，在使用过程中算是比较顺利。（免费版在使用的时候会
stm32wifi模块客户端与热点
最新发布
07-21
在连接过程中，WiFi模块会扫描附近的热点，并与指定的热点进行认证和连接。认证过程中，WiFi模块会向热点发送认证请求，包括安全证书（如果需要）和密码等信息。如果认证成功，WiFi模块将与热点建立TCP/IP连接。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值