精华内容
下载资源
问答
  • 在LINUX命令行中管理 Wifi 连接

    千次阅读 2016-08-11 19:25:30
    在命令行中管理 Wifi 连接 通过命令行来设置连接WiFi 当然有很多种方法,但在这篇文章里,同时也是一个建议,我使用最基本的方法:那就是使用在任何发布版本中都有的包含在“默认包”里的程序和工具。或者说...

    在命令行中管理 Wifi 连接

    通过命令行来设置连接到 WiFi 当然有很多种方法,但在这篇文章里,同时也是一个建议,我使用最基本的方法:那就是使用在任何发布版本中都有的包含在“默认包”里的程序和工具。或者说我偏向于使用这一种方法。使用此方法显而易见的好处是这个操作过程能在任意有 Linux 系统的机器上复用。不好的一点是它相对来说比较复杂。

    首先,我假设您们都已经正确安装了无线网卡的驱动程序。没有这前提,后续的一切都如镜花水月。如果您你机器确实没有正确安装上,您应该看看关于您的发布版本的维基和文档。

    使用命令行设置树莓派的Wifi网络 http://www.linuxidc.com/Linux/2014-10/107546.htm

    Ubuntu 下建立Wifi热点的方法 http://www.linuxidc.com/Linux/2014-07/104624.htm

    ArchLinux下的Wifi(无线)问题解决 http://www.linuxidc.com/Linux/2014-04/99751.htm

    Android Wifi Ralink RT3070开发记录 http://www.linuxidc.com/Linux/2014-03/97631.htm

    为Ubuntu笔记本电脑创建Wifi热点共享上网 http://www.linuxidc.com/Linux/2014-02/97139.htm

    如何使用BackTrack破解Wifi无线网络的WEP密钥 http://www.linuxidc.com/Linux/2013-12/94120.htm

    然后您就可以用如下命令来检查是哪一个接口来支持无线连接的:

    1. $ iwconfig

    一般来说,无线接口都叫做 wlan0。当然也有例外的,但在这篇教程中我们将会一直用通用叫法。

    以防万一,你得确认下以使此接口服务是启动着的:

    1. $ sudo ip link set wlan0 up

    一但确认了无线接口是工作着的,你就可以用如下命令来扫描附近的无线网络了:

    1. $ sudo iw dev wlan0 scan | less

    根据扫描出的结果,可以得到网络的名字(它的 SSID),它的信息强度,以及它使用的是哪个安全加密的(如:WEP、WPA/WPA2)。从此时起,将会分成两条路线:情况很好、很容易的以及情况稍微复杂的。

    如果您想连接的网络是没有加密的,您可以用下面的命令直接连接:

    1. $ sudo iw dev wlan0 connect [网络 SSID]

    如果网络是用 WEP 加密的,也非常容易:

    1. $ sudo iw dev wlan0 connect [网络 SSID] key 0:[WEP 密钥]

    但网络使用的是 WPA 或 WPA2 协议的话,事情就不好办了。这种情况,您就得使用叫做 wpasupplicant 的工具,它默认是没有的。然后需要修改 /etc/wpasupplicant/wpa_supplicant.conf 文件,增加如下行:

    1. network={
    2. ssid="[网络 ssid]"
    3. psk="[密码]"
    4. priority=1
    5. }

    我建议你​​在文件的末尾添加它,并确保其他配置都注释掉。要注意 SSID 和密码字串都是大小写敏感的。在技术上您也可以把接入点的名称当做是 SSID,使用 wpa_supplicant 工具的话会有合适的 SSID 来替代这个名字。

    一旦配置文件修改完成后,在后台启动此命令:

    1. $ sudo wpa_supplicant -i wlan0 -/etc/wpa_supplicant/wpa_supplicant.conf

    最后,无论是连到开放的网络还是加密的安全网络,您都得获取 IP 地址。简单地使用如下命令:

    1. $ sudo dhcpcd wlan0

    如果一切顺利的话,您应该已经通过 DHCP 获取到了一个全新的本地 IP,这个过程是在后台自动完成的。如果想确认下是否真正连接上的话,您可以再一次输入如下命令检查:

    1. $ iwconfig

    最后,我认为多次重复第一步的检查操作是很有必要的。您永远不会知道什么时候您的图形用户界面挂了,或者是什么时候不能访问无线连接了,所以现在就准备着用命令来检测吧。还有,前面提到过的,有很多种方式(如 NetworkManager、wicdnetcfgwifi 等等)来管理无线连接。我坚持使用最基本的方式,但在某些情况下,我使用的工具可能您还没有,所以您在之前就得先下载它们。另一方面,有很多高级的应用程序,他们确实是不包含在“默认包”里面的,使用它们会大大简化操作过程。但一般建议是开始的话最好从基本的来。

    关于从命令行来管理连接 WiFi 您还有其他方式方法吗?请在评论中让我们知道。

    本文永久更新链接地址http://www.linuxidc.com/Linux/2014-10/108096.htm


    展开全文
  • android wifi连接与断开

    千次阅读 2015-10-07 17:52:56
    android 实现wifi连接与断开 可以完全代替系统设置的wifi管理功能,搜索wifi按照信号强度排序,button刷新,记住密码等功能

    android 实现wifi连接与断开 可以完全代替系统设置的wifi管理功能,搜索wifi按照信号强度排序,button刷新,记住密码等功能

    源码地址:http://download.csdn.net/detail/u014774589/9161089

    LinkWifi.java

    package com.example.wifitest;
    
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.Iterator;
    import java.util.List;
    
    import android.app.Service;
    import android.content.Context;
    import android.net.wifi.ScanResult;
    import android.net.wifi.WifiConfiguration;
    import android.net.wifi.WifiManager;
    
    public class LinkWifi {
    
    	private WifiManager wifiManager;
    
    	/** 定义几种加密方式,一种是WEP,一种是WPA/WPA2,还有没有密码的情况 */
    	public enum WifiCipherType {
    		WIFI_CIPHER_WEP, WIFI_CIPHER_WPA_EAP, WIFI_CIPHER_WPA_PSK, WIFI_CIPHER_WPA2_PSK, WIFI_CIPHER_NOPASS
    	}
    
    	public LinkWifi(Context context) {
    		wifiManager = (WifiManager) context
    				.getSystemService(Service.WIFI_SERVICE);
    	}
    	
    	/**
    	 * 检测wifi状态 opened return true;
    	 */
    	public boolean checkWifiState() {
    		boolean isOpen = true;
    		int wifiState = wifiManager.getWifiState();
    
    		if (wifiState == WifiManager.WIFI_STATE_DISABLED
    				|| wifiState == WifiManager.WIFI_STATE_DISABLING
    				|| wifiState == WifiManager.WIFI_STATE_UNKNOWN
    				|| wifiState == WifiManager.WIFI_STATE_ENABLING) {
    			isOpen = false;
    		}
    
    		return isOpen;
    	}
    
    
    	public boolean ConnectToNetID(int netID) {
    		return wifiManager.enableNetwork(netID, true);
    	}
    
    	/** 查看以前是否也配置过这个网络 */
    	public WifiConfiguration IsExsits(String SSID) {
    		List<WifiConfiguration> existingConfigs = wifiManager
    				.getConfiguredNetworks();
    
    		for (WifiConfiguration existingConfig : existingConfigs) {
    
    			if (existingConfig.SSID.toString().equals("\"" + SSID + "\"")) {
    				return existingConfig;
    			}
    		}
    		return null;
    	}
    
    	public int CreateWifiInfo2(ScanResult wifiinfo, String pwd) {
    		WifiCipherType type;
    
    		if (wifiinfo.capabilities.contains("WPA2-PSK")) {
    			// WPA-PSK加密
    			type = WifiCipherType.WIFI_CIPHER_WPA2_PSK;
    		} else if (wifiinfo.capabilities.contains("WPA-PSK")) {
    			// WPA-PSK加密
    			type = WifiCipherType.WIFI_CIPHER_WPA_PSK;
    		} else if (wifiinfo.capabilities.contains("WPA-EAP")) {
    			// WPA-EAP加密
    			type = WifiCipherType.WIFI_CIPHER_WPA_EAP;
    		} else if (wifiinfo.capabilities.contains("WEP")) {
    			// WEP加密
    			type = WifiCipherType.WIFI_CIPHER_WEP;
    		} else {
    			// 无密码
    			type = WifiCipherType.WIFI_CIPHER_NOPASS;
    		}
    
    		WifiConfiguration config = CreateWifiInfo(wifiinfo.SSID,
    				wifiinfo.BSSID, pwd, type);
    		if (config != null) {
    			return wifiManager.addNetwork(config);
    		} else {
    			return -1;
    		}
    	}
    
    	public WifiConfiguration setMaxPriority(WifiConfiguration config) {
    		int priority = getMaxPriority() + 1;
    		if (priority > 99999) {
    			priority = shiftPriorityAndSave();
    		}
    
    		config.priority = priority; 
    		wifiManager.updateNetwork(config);
    
    		// 本机之前配置过此wifi热点,直接返回
    		return config;
    	}
    
    	/** 配置一个连接 */
    	public WifiConfiguration CreateWifiInfo(String SSID, String BSSID,
    			String password, WifiCipherType type) {
    
    		int priority;
    
    		WifiConfiguration config = this.IsExsits(SSID);
    		if (config != null) {
    			// 本机之前配置过此wifi热点,调整优先级后,直接返回
    			return setMaxPriority(config);
    		}
    
    		config = new WifiConfiguration();
    		/* 清除之前的连接信息 */
    		config.allowedAuthAlgorithms.clear();
    		config.allowedGroupCiphers.clear();
    		config.allowedKeyManagement.clear();
    		config.allowedPairwiseCiphers.clear();
    		config.allowedProtocols.clear();
    		config.SSID = "\"" + SSID + "\"";
    		config.status = WifiConfiguration.Status.ENABLED;
    
    		priority = getMaxPriority() + 1;
    		if (priority > 99999) {
    			priority = shiftPriorityAndSave();
    		}
    
    		config.priority = priority; // 2147483647;
    		/* 各种加密方式判断 */
    		if (type == WifiCipherType.WIFI_CIPHER_NOPASS) {
    			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
    			config.wepTxKeyIndex = 0;
    		} else if (type == WifiCipherType.WIFI_CIPHER_WEP) {
    			config.preSharedKey = "\"" + 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;
    		} else if (type == WifiCipherType.WIFI_CIPHER_WPA_EAP) {
    
    			config.preSharedKey = "\"" + password + "\"";
    			config.hiddenSSID = true;
    			config.status = WifiConfiguration.Status.ENABLED;
    			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
    
    			config.allowedPairwiseCiphers
    					.set(WifiConfiguration.PairwiseCipher.TKIP);
    			config.allowedPairwiseCiphers
    					.set(WifiConfiguration.PairwiseCipher.CCMP);
    			config.allowedProtocols.set(WifiConfiguration.Protocol.RSN
    					| WifiConfiguration.Protocol.WPA);
    
    		} else if (type == WifiCipherType.WIFI_CIPHER_WPA_PSK) {
    
    			config.preSharedKey = "\"" + password + "\"";
    			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    
    			config.allowedPairwiseCiphers
    					.set(WifiConfiguration.PairwiseCipher.TKIP);
    			config.allowedPairwiseCiphers
    					.set(WifiConfiguration.PairwiseCipher.CCMP);
    			config.allowedProtocols.set(WifiConfiguration.Protocol.RSN
    					| WifiConfiguration.Protocol.WPA);
    
    		} else if (type == WifiCipherType.WIFI_CIPHER_WPA2_PSK) {
    
    			config.preSharedKey = "\"" + password + "\"";
    			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
    			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
    
    			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
    
    			config.allowedPairwiseCiphers
    					.set(WifiConfiguration.PairwiseCipher.TKIP);
    			config.allowedPairwiseCiphers
    					.set(WifiConfiguration.PairwiseCipher.CCMP);
    			config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
    			config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
    
    		} else {
    			return null;
    		}
    
    		return config;
    	}
    
    	private int getMaxPriority() {
    		List<WifiConfiguration> localList = this.wifiManager
    				.getConfiguredNetworks();
    		int i = 0;
    		Iterator<WifiConfiguration> localIterator = localList.iterator();
    		while (true) {
    			if (!localIterator.hasNext())
    				return i;
    			WifiConfiguration localWifiConfiguration = (WifiConfiguration) localIterator
    					.next();
    			if (localWifiConfiguration.priority <= i)
    				continue;
    			i = localWifiConfiguration.priority;
    		}
    	}
    
    	private int shiftPriorityAndSave() {
    		List<WifiConfiguration> localList = this.wifiManager
    				.getConfiguredNetworks();
    		sortByPriority(localList);
    		int i = localList.size();
    		for (int j = 0;; ++j) {
    			if (j >= i) {
    				this.wifiManager.saveConfiguration();
    				return i;
    			}
    			WifiConfiguration localWifiConfiguration = (WifiConfiguration) localList
    					.get(j);
    			localWifiConfiguration.priority = j;
    			this.wifiManager.updateNetwork(localWifiConfiguration);
    		}
    	}
    
    	private void sortByPriority(List<WifiConfiguration> paramList) {
    		Collections.sort(paramList, new SjrsWifiManagerCompare());
    	}
    
    	class SjrsWifiManagerCompare implements Comparator<WifiConfiguration> {
    		public int compare(WifiConfiguration paramWifiConfiguration1,
    				WifiConfiguration paramWifiConfiguration2) {
    			return paramWifiConfiguration1.priority
    					- paramWifiConfiguration2.priority;
    		}
    	}
    }
    


    WifiRelayListAdapter.java

    package com.example.wifitest;
    
    import java.util.List;
    
    import com.sjrs08.wifitest.R;
    
    import android.app.Service;
    import android.content.Context;
    import android.net.wifi.ScanResult;
    import android.net.wifi.WifiManager;
    import android.os.Handler;
    import android.os.Message;
    import android.view.LayoutInflater;
    import android.view.MotionEvent;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.BaseAdapter;
    import android.widget.ImageView;
    import android.widget.TextView;
    
    public class WifiRelayListAdapter extends BaseAdapter {
    
    	private Context context;
    	private List<ScanResult> wifiList;
    	private Handler setWifiHandler = null;
    
    	public WifiRelayListAdapter(Context context, List<ScanResult> wifiList,
    			Handler setWifiHandler) {
    		this.context = context;
    		this.wifiList = wifiList;
    		this.setWifiHandler = setWifiHandler;
    	}
    
    	@Override
    	public int getCount() {
    		return wifiList.size();
    	}
    
    	@Override
    	public Object getItem(int position) {
    		return null;
    	}
    
    	@Override
    	public long getItemId(int position) {
    		return 0;
    	}
    
    	@Override
    	public View getView(int position, View convertView, ViewGroup parent) {
    		// convertView为null的时候初始化convertView。
    		if (convertView == null) {
    			LayoutInflater inflater = (LayoutInflater) context
    					.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    			convertView = inflater.inflate(R.layout.wifi_child, null);
    		}
    		final ScanResult childData = wifiList.get(position);
    
    		/**
    		 * 加载资源
    		 */
    		ImageView wifi_state = (ImageView) convertView
    				.findViewById(R.id.wifi_state);
    
    		TextView wifi_info_text = (TextView) convertView
    				.findViewById(R.id.wifi_info);
    		TextView wifi_lock_text = (TextView) convertView
    				.findViewById(R.id.wifi_lock);
    
    		wifi_info_text.setText(childData.SSID); // + "(" + childData.BSSID + ")");
    
    		String lock_str;
    		boolean lock_type = true;
    
    		if (childData.capabilities.contains("WPA2-PSK")) {
    			// WPA-PSK加密
    			lock_str = "通过WPA2-PSK进行保护";
    		} else if (childData.capabilities.contains("WPA-PSK")) {
    			// WPA-PSK加密
    			lock_str = "通过WPA-PSK进行保护";
    		} else if (childData.capabilities.contains("WPA-EAP")) {
    			// WPA-EAP加密
    			lock_str = "通过WPA-EAP进行保护";
    		} else if (childData.capabilities.contains("WEP")) {
    			// WEP加密
    			lock_str = "通过WEP进行保护";
    		} else {
    			// 无密码
    			lock_str = "开放网络";
    			lock_type = false;
    		}
    
    		LinkWifi linkWifi = new LinkWifi(context);
    		WifiManager wifiManager = (WifiManager) context
    				.getSystemService(Service.WIFI_SERVICE);
    
    		if (linkWifi.IsExsits(childData.SSID) != null
    				&& linkWifi.IsExsits(childData.SSID).networkId == wifiManager
    						.getConnectionInfo().getNetworkId()) {
    			lock_str+="(已连接)";
    		}
    
    		wifi_lock_text.setText(lock_str);
    
    		// 点击的话,中继该无线
    		convertView.setOnClickListener(new OnClickListener() {
    			public void onClick(View arg0) {
    				if (setWifiHandler != null) {
    					Message msg = new Message();
    					msg.what = 0;
    					msg.obj = childData;
    					setWifiHandler.sendMessage(msg);
    				}
    			}
    		});
    
    		convertView.setOnTouchListener(new View.OnTouchListener() {
    
    			public boolean onTouch(View arg0, MotionEvent arg1) {
    				if (arg1.getAction() == MotionEvent.ACTION_DOWN) {
    					arg0.setBackgroundColor(0xaa333333);
    				} else {
    					arg0.setBackgroundColor(0x00ffffff);
    				}
    
    				return false; // 表示继续传递该消息,如果返回true则表示该消息不再被传递
    			}
    		});
    
    		if (childData.level < -90) {
    			if (lock_type)
    				wifi_state.setBackgroundResource(R.drawable.wifilevel0_lock);
    			else
    				wifi_state.setBackgroundResource(R.drawable.wifilevel0);
    		} else if (childData.level < -85) {
    			if (lock_type)
    				wifi_state.setBackgroundResource(R.drawable.wifilevel1_lock);
    			else
    				wifi_state.setBackgroundResource(R.drawable.wifilevel1);
    		} else if (childData.level < -70) {
    			if (lock_type)
    				wifi_state.setBackgroundResource(R.drawable.wifilevel2_lock);
    			else
    				wifi_state.setBackgroundResource(R.drawable.wifilevel2);
    		} else if (childData.level < -60) {
    			if (lock_type)
    				wifi_state.setBackgroundResource(R.drawable.wifilevel3_lock);
    			else
    				wifi_state.setBackgroundResource(R.drawable.wifilevel3);
    		} else if (childData.level < -50) {
    			if (lock_type)
    				wifi_state.setBackgroundResource(R.drawable.wifilevel4_lock);
    			else
    				wifi_state.setBackgroundResource(R.drawable.wifilevel4);
    		}
    
    		convertView.setTag("wifi_" + childData.BSSID);
    
    		return convertView;
    	}
    
    }
    


    MainActivity
    package com.example.wifitest;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;
    
    import com.sjrs08.wifitest.R;
    
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.app.Service;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.DialogInterface;
    import android.content.Intent;
    import android.content.IntentFilter;
    import android.net.wifi.ScanResult;
    import android.net.wifi.WifiConfiguration;
    import android.net.wifi.WifiManager;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.Window;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.ListView;
    import android.widget.TextView;
    import android.widget.Toast;
    
    public class MainActivity extends Activity {
    	private WifiManager wifiManager = null;
    	private Context context = null;
    	public SetWifiHandler setWifiHandler;
    	private WifiRelayListAdapter wifiListAdapter;
    	private WifiRelayListAdapter havelink_wifiListAdapter;
    	private ListView wifi_list;
    	private ListView havelink_wifi;
    	private Button refresh_list_btn;
    	private Button wifi_on_off_btn;
    	private TextView wifi_tip;
    
    	private LinkWifi linkWifi;
     
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.layout_setwifirelay);
    		context = this;
    		linkWifi = new LinkWifi(context);
    
    		wifiManager = (WifiManager) context
    				.getSystemService(Service.WIFI_SERVICE);
    
    		setWifiHandler = new SetWifiHandler(Looper.getMainLooper());
    
    		wifi_list = (ListView) findViewById(R.id.wifi_list);
    		havelink_wifi = (ListView) findViewById(R.id.havelink_wifi);
    		refresh_list_btn = (Button) findViewById(R.id.refresh_list_btn);
    		wifi_on_off_btn = (Button) findViewById(R.id.wifi_on_off_btn);
    		wifi_tip = (TextView) findViewById(R.id.wifi_tip);
    
    
    		refresh_list_btn.setOnClickListener(new OnClickListener() {
    			public void onClick(View arg0) {
    				Toast.makeText(context, "刷新wifi列表!", Toast.LENGTH_LONG).show();
    				// 刷新wifi列表
    				wifiManager.startScan();
    			}
    		});
    
    		if (linkWifi.checkWifiState()) {
    			wifi_on_off_btn.setBackgroundResource(R.drawable.wifi_on);
    			wifi_tip.setVisibility(View.VISIBLE);
    		} else {
    			wifi_on_off_btn.setBackgroundResource(R.drawable.wifi_off);
    			wifi_tip.setVisibility(View.INVISIBLE);
    		}
    
    		wifi_on_off_btn.setOnClickListener(new OnClickListener() {
    			public void onClick(View arg0) {
    				wifiManager.setWifiEnabled(!linkWifi.checkWifiState());
    			}
    		});
    
    		regWifiReceiver();
    		scanAndGetResult();
    	}
    
    //	@Override
    //	public boolean onCreateOptionsMenu(Menu menu) {
    //		getMenuInflater().inflate(R.menu.main, menu);
    //		return true;
    //	}
    
    //	@Override
    //	public boolean onOptionsItemSelected(MenuItem item) {
    //		switch (item.getItemId()) {
    //		default:
    //			new AlertDialog.Builder(context)
    //					.setTitle("关于")
    //					.setMessage("SJRS的无线管理演示\nQQ:568626884\n版本:V1.0(1)\n2014.10.24")
    //					.setPositiveButton("确定",
    //							new DialogInterface.OnClickListener() {
    //								public void onClick(DialogInterface dialog,
    //										int whichButton) {
    //
    //									return;
    //								}
    //							}).show();
    //			break;
    //		}
    //		return false;
    //	}
    
    	private void regWifiReceiver() {
    		IntentFilter labelIntentFilter = new IntentFilter();
    		labelIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
    		labelIntentFilter.addAction("android.net.wifi.STATE_CHANGE"); 
    		labelIntentFilter.setPriority(1000); // 设置优先级,最高为1000
    		context.registerReceiver(wifiResultChange, labelIntentFilter);
    
    	}
    
    	private void scanAndGetResult() {
    		// 开始扫描
    		wifiManager.startScan();
    		
    	}
    
    	/**
    	 *接收wifi热点改变事件
    	 */
    	private final BroadcastReceiver wifiResultChange = new BroadcastReceiver() {
    		@Override
    		public void onReceive(Context context, Intent intent) {
    
    			String action = intent.getAction();			
    			if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
    				showWifiList();
    			} else if (action.equals("android.net.wifi.STATE_CHANGE")) {
    				// 刷新状态显示
    				showWifiList();			
    			}
    		}
    	};
    
    	private void showWifiList() {
    		// 剔除ssid中的重复项,只保留相同ssid中信号最强的哪一个
    		List<ScanResult> wifiList = wifiManager.getScanResults();
    		List<ScanResult> newWifList = new ArrayList<ScanResult>();
    		List<ScanResult> havelink_Wifi = new ArrayList<ScanResult>();
    		
    		if (linkWifi.checkWifiState()) {
    			wifi_on_off_btn.setBackgroundResource(R.drawable.wifi_on);
    			wifi_tip.setVisibility(View.VISIBLE);
    		} else {
    			wifi_on_off_btn.setBackgroundResource(R.drawable.wifi_off);
    			wifi_tip.setVisibility(View.INVISIBLE);
    		}	
    		if (wifiList != null) {
    			for (int i = 0; i < wifiList.size(); i++) {
    				final ScanResult a = wifiList.get(i);
    				LinkWifi linkWifi = new LinkWifi(context);
    				WifiManager wifiManager = (WifiManager) context
    						.getSystemService(Service.WIFI_SERVICE);
    
    				if (linkWifi.IsExsits(a.SSID) != null
    						&& linkWifi.IsExsits(a.SSID).networkId == wifiManager
    								.getConnectionInfo().getNetworkId()){
    					havelink_Wifi.add(wifiList.get(i));
    				}
    				else{
    					newWifList.add(wifiList.get(i));}
    
    			}
    		}	
    		Collections.sort(newWifList, new Comparator<ScanResult>(){
    			
    			@Override
    			public int compare(ScanResult oldval, ScanResult newval) {
    				int data1 = oldval.level;
    				int data2 = newval.level;
    				if(data1 < data2)
    				{
    					return 1;
    				}
    				return -1;
    			}
    			
    		});
    		wifiListAdapter = new WifiRelayListAdapter(context, newWifList,
    				setWifiHandler);
    		havelink_wifiListAdapter = new WifiRelayListAdapter(context, havelink_Wifi, setWifiHandler);
    		havelink_wifi.setAdapter(havelink_wifiListAdapter);
    		wifi_list.setAdapter(wifiListAdapter);
    	}
    
    	public class SetWifiHandler extends Handler {
    		public SetWifiHandler(Looper mainLooper) {
    			super(mainLooper);
    		}
    
    		public void handleMessage(Message msg) {
    			switch (msg.what) {
    			case 0:// 请求操作某一无线网络
    				ScanResult wifiinfo = (ScanResult) msg.obj;
    				configWifiRelay(wifiinfo);
    				break;
    
    			}
    		}
    	}
    
    	private void configWifiRelay(final ScanResult wifiinfo) {
    		// 如果本机已经配置过的话
    		if (linkWifi.IsExsits(wifiinfo.SSID) != null) {
    			final int netID = linkWifi.IsExsits(wifiinfo.SSID).networkId;
    
    			String actionStr;
    			// 如果目前连接了此网络
    			if (wifiManager.getConnectionInfo().getNetworkId() == netID) {
    				actionStr = "断开";
    			} else {
    				actionStr = "连接";
    			}
    			new AlertDialog.Builder(context)
    					.setTitle("提示")
    					.setMessage("请选择你要进行的操作?")
    					.setPositiveButton(actionStr,
    							new DialogInterface.OnClickListener() {
    								public void onClick(DialogInterface dialog,
    										int whichButton) {
    
    									if (wifiManager.getConnectionInfo()
    											.getNetworkId() == netID) {
    										wifiManager.disconnect();
    									} else {
    										WifiConfiguration config = linkWifi
    												.IsExsits(wifiinfo.SSID);
    										linkWifi.setMaxPriority(config);
    										linkWifi.ConnectToNetID(config.networkId);
    									}
    
    								}
    							})
    					.setNeutralButton("忘记",
    							new DialogInterface.OnClickListener() {
    								public void onClick(DialogInterface dialog,
    										int whichButton) {
    									wifiManager.removeNetwork(netID);
    									return;
    								}
    							})
    					.setNegativeButton("取消",
    							new DialogInterface.OnClickListener() {
    								public void onClick(DialogInterface dialog,
    										int whichButton) {
    									return;
    								}
    							}).show();
    
    			return;
    		}
    
    		String capabilities = "";
    
    		if (wifiinfo.capabilities.contains("WPA2-PSK")) {
    			// WPA-PSK加密
    			capabilities = "psk2";
    		} else if (wifiinfo.capabilities.contains("WPA-PSK")) {
    			// WPA-PSK加密
    			capabilities = "psk";
    		} else if (wifiinfo.capabilities.contains("WPA-EAP")) {
    			// WPA-EAP加密
    			capabilities = "eap";
    		} else if (wifiinfo.capabilities.contains("WEP")) {
    			// WEP加密
    			capabilities = "wep";
    		} else {
    			// 无密码
    			capabilities = "";
    		}
    
    		if (!capabilities.equals("")) {
    			// 有密码,提示输入密码进行连接
    
    			LayoutInflater factory = LayoutInflater.from(context);
    			final View inputPwdView = factory.inflate(R.layout.dialog_inputpwd,
    					null);
    			new AlertDialog.Builder(context)
    					.setTitle("请输入该无线的连接密码")
    					.setMessage("无线SSID:" + wifiinfo.SSID)
    					.setIcon(android.R.drawable.ic_dialog_info)
    					.setView(inputPwdView)
    					.setPositiveButton("确定",
    							new DialogInterface.OnClickListener() {
    								public void onClick(DialogInterface dialog,
    										int which) {
    									EditText pwd = (EditText) inputPwdView
    											.findViewById(R.id.etPassWord);
    									String wifipwd = pwd.getText().toString();
    
    									// 此处加入连接wifi代码
    									int netID = linkWifi.CreateWifiInfo2(
    											wifiinfo, wifipwd);
    
    									linkWifi.ConnectToNetID(netID);
    								}
    							})
    					.setNegativeButton("取消",
    							new DialogInterface.OnClickListener() {
    								@Override
    								public void onClick(DialogInterface dialog,
    										int which) {
    								}
    							}).setCancelable(false).show();
    
    		} else {
    			// 无密码
    			new AlertDialog.Builder(context)
    					.setTitle("提示")
    					.setMessage("你选择的wifi无密码,可能不安全,确定继续连接?")
    					.setPositiveButton("确定",
    							new DialogInterface.OnClickListener() {
    								public void onClick(DialogInterface dialog,
    										int whichButton) {
    
    									// 此处加入连接wifi代码
    									int netID = linkWifi.CreateWifiInfo2(
    											wifiinfo, "");
    
    									linkWifi.ConnectToNetID(netID);
    								}
    							})
    					.setNegativeButton("取消",
    							new DialogInterface.OnClickListener() {
    								public void onClick(DialogInterface dialog,
    										int whichButton) {
    									return;
    								}
    							}).show();
    
    		}
    
    	}
    
    	@Override
    	public void onDestroy() {
    		super.onDestroy();
    		context.unregisterReceiver(wifiResultChange); // 注销此广播接收器
    	}
    
    }
    



    展开全文
  • Android连接WiFi

    千次阅读 2019-05-21 10:36:04
    * WiFi连接管理 * 申请权限 * <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/> * <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/> * ...

    WiFi打开、连接、关闭

    /**
     * WiFi连接管理
     * 申请权限
     * <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
     * <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
     * <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
     * <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
     * 动态权限
     * Manifest.permission.ACCESS_COARSE_LOCATION
     * Manifest.permission.ACCESS_FINE_LOCATION
     *
     */
    public class WifiUtils {
        private static WifiUtils utils = null;
    
        public WifiUtils(Context context){
            wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        }
    
        public static WifiUtils getInstance(Context context){
            if (utils == null){
                synchronized (WifiUtils.class){
                    if (utils == null){
                        utils = new WifiUtils(context);
                    }
                }
            }
            return utils;
        }
    
        private WifiManager wifiManager;
    
        /**
         * wifi是否打开
         * @return
         */
        public boolean isWifiEnable(){
            boolean isEnable = false;
            if (wifiManager != null){
                if (wifiManager.isWifiEnabled()){
                    isEnable = true;
                }
            }
            return isEnable;
        }
    
        /**
         * 打开WiFi
         */
        public void openWifi(){
            if (wifiManager != null && !isWifiEnable()){
                wifiManager.setWifiEnabled(true);
            }
        }
    
        /**
         * 关闭WiFi
         */
        public void closeWifi(){
            if (wifiManager != null && isWifiEnable()){
                wifiManager.setWifiEnabled(false);
            }
        }
    
        /**
         * 获取WiFi列表
         * @return
         */
        public List<ScanResult> getWifiList(){
            List<ScanResult> resultList = new ArrayList<>();
            if (wifiManager != null && isWifiEnable()){
                resultList.addAll(wifiManager.getScanResults());
            }
            return resultList;
        }
    
        /**
         * 有密码连接
         * @param ssid
         * @param pws
         */
        public void connectWifiPws(String ssid, String pws){
            wifiManager.disableNetwork(wifiManager.getConnectionInfo().getNetworkId());
            int netId = wifiManager.addNetwork(getWifiConfig(ssid, pws, true));
            wifiManager.enableNetwork(netId, true);
        }
    
        /**
         * 无密码连接
         * @param ssid
         */
        public void connectWifiNoPws(String ssid){
            wifiManager.disableNetwork(wifiManager.getConnectionInfo().getNetworkId());
            int netId = wifiManager.addNetwork(getWifiConfig(ssid, "", false));
            wifiManager.enableNetwork(netId, true);
        }
    
        /**
         * wifi设置
         * @param ssid
         * @param pws
         * @param isHasPws
         */
        private WifiConfiguration getWifiConfig(String ssid, String pws, boolean isHasPws){
            WifiConfiguration config = new WifiConfiguration();
            config.allowedAuthAlgorithms.clear();
            config.allowedGroupCiphers.clear();
            config.allowedKeyManagement.clear();
            config.allowedPairwiseCiphers.clear();
            config.allowedProtocols.clear();
            config.SSID = "\"" + ssid + "\"";
    
            WifiConfiguration tempConfig = isExist(ssid);
            if(tempConfig != null) {
                wifiManager.removeNetwork(tempConfig.networkId);
            }
            if (isHasPws){
                config.preSharedKey = "\""+pws+"\"";
                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.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
                config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
                config.status = WifiConfiguration.Status.ENABLED;
            }else {
                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            }
            return config;
        }
    
        /**
         * 得到配置好的网络连接
         * @param ssid
         * @return
         */
        private WifiConfiguration isExist(String ssid) {
            List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();
            for (WifiConfiguration config : configs) {
                if (config.SSID.equals("\""+ssid+"\"")) {
                    return config;
                }
            }
            return null;
        }
    }
    
    	<receiver android:name=".MyBroadcastReceiver">
             <intent-filter android:priority="1000">
                 <action android:name="android.intent.action.CONFIGURATION_CHANGED"/>
                 <action android:name="android.net.wifi.WIFI_STATE_CHANGED" />
                 <action android:name="android.net.wifi.STATE_CHANGE" />
             </intent-filter>
        </receiver>
    public class MyBroadcastReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent != null
                    && WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())){
                Log.e("======", "NETWORK_STATE_CHANGED_ACTION");
                Parcelable parcelable = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (parcelable != null){
                    NetworkInfo networkInfo = (NetworkInfo) parcelable;
                    NetworkInfo.State state = networkInfo.getState();
                    boolean isConnect = state == NetworkInfo.State.CONNECTED;
                    Log.e("======", "isConnect=" + isConnect);
                }
            }
        }
    }
    
    展开全文
  • Wifi连接热点

    千次阅读 2015-12-22 18:54:59
    Wifi连接这一块,网上的资料通常是讲调用WifiManager的两个公开函数: /** * Reconnect to the currently active access point, if we are currently * disconnected. This may result in the asynchronous ...

    Wifi连接热点基本步骤:

    WifiManager wifiManager=(WifiManager) getSystemService(Context.WIFI_SERVICE);
    WifiConfiguration config = new WifiConfiguration();
    config.SSID = convertToQuotedString(scanResult.SSID);
    config.BSSID = scanResult.BSSID;
    .....
    wifiManager.addNetwork(config);
    wifiManager.saveConfiguration();
    config.priority = 100; //需要设置成所有配置中的最高优先级
    wifiManager.enableNetwork(networkId, false);
    wifiManager.reassociate();
    

    基本步骤都是新建或查找配置-》修改配置优化级-》使能网络ID-》连接
    最后一步连接网上的资料通常是讲调用WifiManager的两个公开函数:

    /**
     * Reconnect to the currently active access point, if we are currently
     * disconnected. This may result in the asynchronous delivery of state
     * change events.
     * @return {@code true} if the operation succeeded
     */
    public boolean reconnect();
    
    /**
     * Reconnect to the currently active access point, even if we are already
     * connected. This may result in the asynchronous delivery of state
     * change events.
     * @return {@code true} if the operation succeeded
     */
    public boolean reassociate();
    

    上面已经讲得很清楚了,reconnect只有当wifi是disconnect的时候才会生效,而reassociate无论当前是什么状态都会重连一次。

    实测发现,reconnect在断开连接后调用,会经常连接到上次连接过的热点,而不会连接到新的热点。reassociate每次都会正确连接到新的热点,但是在部分手机上会经常出现连接成功-》断开-》连接的状态,初步分析是因为部分手机在发现断开连接后,会自动扫描并连接热点,目前已在小米,魅族的手机上发现。

    调用这两个函数之前,需要设置好目标热点config的优先级,不然断开后会自动连接到优先级高的热点。

    因为发现以上两个连接函数都有无法解决的问题,所以去看了一个系统自带的wifi管理器WifiSettings的源码,发现WifiSetting在连接的时候,并没有调用这两个函数,而是调用了WifiManager的一个隐藏函数connect(2.3版本及以下是调用reconnect)。通过反射可以调用这个函数,并且解决了以上的问题。这个隐藏函数在不同的系统版本上是不一样的,以下是部分定义:

     * 4.2~
     * public void connect(WifiConfiguration config, ActionListener listener)
     * 
     * 4.1.1 ~ 4.1.2
     * public Channel initialize(Context srcContext, Looper srcLooper, ChannelListener listener)
     * public void connect(Channel c, WifiConfiguration config, ActionListener listener)
     * 
     * 4.0.3 ~ 4.0.4
     * public void connectNetwork(WifiConfiguration config)
     * 
     * 2.2.3 ~ 2.3.6
     * public boolean reconnect()
    

    调用这个函数后,发现切换wifi基本上没有问题了,但是引入了其他的问题: 当wifi刚刚打开(enable)时,调用connect有很大概率让wifiManager的状态变坏,从而无法连接到热点。分析认为,当wifi刚刚打开的时候,系统会自动去连接wifi,这个时候可能状态不稳定,所以插入等待时间直到系统自动连接成功,这时再去连接其他wifi,测试后工作正常,这只是一个临时解决办法,更好的解决办法还需要深入了解wifi的运行机制。


    发现仍然可能会出现问题,继续看wifisettings的源码,发现优先调用的是另一个connect 网络ID的函数,而不是connect配置函数,部分源码如下:

    case MENU_ID_CONNECT: {
                if (mSelectedAccessPoint.networkId != INVALID_NETWORK_ID) {
                   connect(mSelectedAccessPoint.networkId);
                } else if (mSelectedAccessPoint.security == AccessPoint.SECURITY_NONE) {
                   /** Bypass dialog for unsecured networks */
                       mSelectedAccessPoint.generateOpenNetworkConfig();
                       connect(mSelectedAccessPoint.getConfig());
               } else {
                    showDialog(mSelectedAccessPoint, true);
                }
                return true;
            }
    

    然后实际测试发现没有问题了 :)

    虽然问题解决了,但是为什么connect配置的函数不行呢,感觉这里面的原因是复杂的,或许保存配置用的是wifiservice,而连接使用的AsyncChannel? 这是一个值得挖掘的问题,等以后深入学习的时候再看看。

    展开全文
  • wifi连接过程

    千次阅读 2019-02-27 09:24:58
    wifi sta 连接 ap的信令交互过程如下:(DISABLED Security Type) AP-------------->broadcast beacon /** STA Select AP **/ STA ------------> Probe Request ----------------> AP //广播自身数据 ...
  • 你的ubuntu如果使用网线连接上网,可能一点问题都没有, 但是如果想使用 wifi 连接上网可能会遇到问题,如无线网络被禁用,wifi 指示灯没亮等等,上网搜索了很多解决的方法,但都不管用 进入ubuntu,命令行: sudo ...
  • 电脑wifi连接受限

    千次阅读 2017-08-18 15:01:15
    睡了一个程序员觉后,醒来发现电脑怎么也连不上wifi了,各种受限,而室友电脑都连得上,我手机也连得上wifi。这肯定不是电信运营商或者路由器的问题了。那是什么问题呢?就开始百度。 有以下几种办法: 1、...
  • Ubuntu连接WiFi

    万次阅读 2018-05-15 21:33:19
    使用 NetworkManager 工具来管理网络,其在命令行下对应的命令是 nmcli,要连接WiFi,相关的命令如下:查看网络设备列表$ sudo nmcli dev注意,如果列出的设备状态是 unmanaged 的,说明网络设备不受NetworkManager...
  • iMazing出现WiFi连接故障问题

    千次阅读 2018-12-19 11:25:24
    iOS设备和iMazing(http://www.imazing.cc/)之间的WiFi连接取决于Apple的 Bonjour服务。在解决连接问题时,请首先确保没有安全软件阻止Bonjour ,请参阅本文后面 的相关部分。 下载iMazing...
  • 使用命令行连接 wifi

    千次阅读 2018-12-17 20:30:51
    使用命令行连接 wifi 以前尝试过通过命令行连接 wifi,最后没有成功,已经是几年前的印象。继续尝试,我发 现 iwconfig 不支持秘钥,只能用于连接开放的热点。 下面是我在使用命令行连接 wifi 的时候遇到的问题及...
  • 笔记本电脑不显示WIFI列表无法连接到网络的解决办法 笔记本电脑WiFi列表不显示,如下图: 以下以Win10系统来操作演示解决办法; (一)检查网卡驱动是否正常 笔记本电脑突然不显示WiFi列表,多半是因为无线网卡驱动...
  • Qt之连接wifi

    千次阅读 2019-02-08 12:06:07
    最近因为项目需要,我的文件系统是移植好wifi驱动的,所以前面的部分就不描述了,在界面添加wifi连接,所以记录一下自己在探索中的经验和误区 一、无线路由器常见加密方式有WPA-PSK、WPA2-PSK,wpa加密需要用wpa_...
  • centos 7 wifi 连接

    千次阅读 2018-10-07 11:21:25
    1 过程 systemctl start NetworkManager 启动networkManager ...得知无线网卡已经被驱动起来,只是没有纳入NetworkManager的管理。 $ nmcli dev status DEVICE TYPE STATE CONNECTION wlp3s0 wifi unm...
  • android WIFI连接开发

    万次阅读 2013-04-14 12:17:00
    (1)ScanResult,主要是通过wifi 硬件的扫描来获取一些周边的wifi 热点的信息。 在我们进行wifi 搜索的时候,一般会搜到这些信息,首先是接入点名字、接入点信息的强弱、还有接入点使用的安全模式,是WPA、WPE。 ...
  • 安卓系统设置之Wifi连接

    千次阅读 2017-12-12 18:11:18
    安卓系统设置之Wifi连接。在网上查了很多资料,后来找到一个好用的wifi连接
  • 电脑开机之后找不到WiFi,也就是网络连接中WiFi连接选项突然消失的现象我已经遇到了好几次,甚至有一次上网上到一半突然就断了,发现WiFi连接选项消失了。这种情况重启一下电脑通常就能恢复,但问题其实只是无线网卡...
  • centos7 wifi连接

    千次阅读 2017-01-11 16:45:41
    这些天费了九牛二虎之力装wifi,总连不上,最后终于google到了(百度实在垃圾) 网上查的都是用wpa_supplicant连接(我说的 百度),比如: http://www.hailiangchen.com/centos-wireless.html ...
  • 破解手机WIFI连接及密码

    万次阅读 2014-11-07 22:23:00
    或者拿别人的手机想偷用别人的wifi一、查看已保存的wifi密码(已root)1、先用手机下载个RE管理器2、打开RE管理器,找到data这个文件。3、找到data/misc/wifi这个文件,然后进去4、找到wpa-supplicant.conf这个文件...
  • kali linux连接wifi

    千次阅读 2020-07-28 04:50:15
    Arch上面自带的有Wifi-Menu这个命令行WiFi连接工具,kali上却没有,所以就弄了这个小脚本来实现下基本的功能吧。 #!/bin/bash ########################################### # This script file is for configurat
  • 在Android中,ConnectivityManager类代表网络连接服务,它被用来监控网络连接状态,配置失效重连,并控制网络天线等。获取Connectivity Manager实例的方法是使用getSystemService,并指定Context.CONNECTIVITY_...
  • 通过名称,主动连接wifi,获取附近的wifi,对比附近是否有这个wifi
  • Windows 获取已连接WIFI密码

    千次阅读 2021-06-02 09:27:34
    获取当前已连接WIFI密码 打开控制面板,选择网络与共享中心: 点击当前连接wifi: ...2 输入命令netsh wlan show profiles,获取已连接过的WIFI名称: 3 使用命令netsh wlan show profile name=“WIFI名称”
  • adb通过wifi连接android设备

    万次阅读 多人点赞 2017-02-07 16:54:28
    问题背景 近期的项目测试中,需要将移动设备与厂商机器进行usb连接视频传输(投屏)。...adb支持usb连接模式和tcpip连接模式,我们可以用tcpip模式通过wifi无线连接adb。 其他应用场景 usb线比较松的时候,adb连接
  • Redhat linux命令行连接wifi

    千次阅读 2019-04-24 19:54:17
    redhat连接wifi 在终端获取管理员权限,或者直接用管理员帐号登陆 1 su 紧接着输入管理员密码,若你已经是管理员帐号,可跳过这一步。 2 输入如下命令行查看无线网卡接口: iw dev 查看无线网卡名称,我...
  • 使用nmcli命令配置WiFi连接 目前各大Linux发行版通常都用NetworkManager来管理网络,对应的命令行工具是nmcli,可以很便捷地对网络进行配置。 以Ubuntu 20.04为例,使用nmcli新建一个WiFi连接的命令如下: 新建wifi ...
  • 关于网友提出的“Android 如何获取所有的wifi连接历史记录?”问题疑问,本网通过在网上对“Android 如何获取所有的wifi连接历史记录?”有关的相关答案进行了整理,供用户进行参考,详细问题解答如下:问题:...
  • 首先确保计算机已经安装无线网卡驱动程序,使用如图的命令进行检查哪个端口支持无线连接,一般都是wlan0但也不包括特殊的.然后查看这个接口是否为启动状态,如果是关闭状态就需要改为启动状态,使用如图的命令进行扫描...
  • ubuntu命令行连接wifi

    千次阅读 2019-10-18 15:54:32
    一直都是用图形界面连接wifi,但是有时候发现很多时候只能用命令行, 通过网上查了下,发现无线连接的命令还是比较混乱,并没有在使用上形成统一。不同系统,硬件,结果还不一样。我用的ubuntu14的系统,tplink的USB...
  • window10 wifi连接自动断开解决方案

    千次阅读 2019-06-30 01:34:23
    window10系统总会出现 开机一会不玩,wifi自动断开,再连接就连不上了,电脑重启就好了。 但是这毕竟不是长久之计,需要从根源解决问题。 控制面板---网络和 Internet---网络和共享中心---更改适配器设置 找到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,799
精华内容 19,919
关键字:

下载wifi连接管理器