android wifi连接与断开

其他 2018-07-25 12:09:55 阅读次数: 0

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); // 注销此广播接收器
	}

}



猜你喜欢

转载自blog.csdn.net/u014774589/article/details/48950727
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022