android wifi操作，热点创建

　手机作为一种移动设备，自然是十分依赖Wifi的，通过Wifi我们才得以和其它的手机与电脑进行通信，下面说一下我对Wifi的理解，首先Wifi绝不是一种网络连接方式，Wifi只是网络连接的一种途径，通过Wifi我们可以连接到某一通向外网的路由器上，从而访问外网，也可以通过wifi组成一个小型局域网，与局域网内部的其它设备进行通信，这才是wfi最重要的作用．

　最近由于项目需要，要操作到手机Wifi,通过wifi连接到某一路由器从而与其它设备通信，开始，我采取的思路是局域网内的另一台设备做为热点，我的手机去连接它的热点，发现连接是可以连接上，但此时手机的wifi通道被占用，手机无法再连接到其它的网络了，这时手机就无法访问互联网，无奈只好采用另一种方式，就是让我的手机开热点，而其它设备连接我手机的热点，这样就不影响手机的上网，也能组成一个小型局域网与其它设备进行通信，折腾一番后，就将所有wifi操作封装为一个类，方便以后重用此类．．．声明以下这个类参考了网上许多大神的代码,自己主要是做了一个封装．

package com.example.wifidemo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiManager.WifiLock;
import android.util.Log;

/**
 * Wifi操作工具类，将WifiManager的操作封闭了一层
 * 
 * @author rzq
 */
public class WifiAdmin {

	private static WifiAdmin instance = null;
	/**
	 * Wifi操作类
	 */
	private WifiManager mWifiManager;
	/**
	 * 当前链接热点的详细信息(如果有连接的话)
	 */
	private WifiInfo mWifiInfo;
	/**
	 * 附近所有可用热点集合
	 */
	private List<ScanResult> mWifiList;
	/**
	 * 附近所有热点的配置信息
	 */
	private ArrayList<WifiConfiguration> mWifiConfigurations;
	private WifiLock mWifiLock;

	private WifiAdmin(Context context) {

		mWifiManager = (WifiManager) context
				.getSystemService(Context.WIFI_SERVICE);
		// 返回当前连接的WIFI信息
		mWifiInfo = mWifiManager.getConnectionInfo();
	}

	public static WifiAdmin getInstance(Context context) {

		if (instance == null) {

			instance = new WifiAdmin(context);
		}
		return instance;
	}

	/**
	 * 打开Wifi..
	 */
	public void openWifi() {

		if (!mWifiManager.isWifiEnabled()) {
			mWifiManager.setWifiEnabled(true);
		}
	}

	/**
	 * 关闭Wifi
	 */
	public void closeWifi() {

		if (mWifiManager.isWifiEnabled()) {

			mWifiManager.setWifiEnabled(false);
		}
	}

	// 检查当前wifi状态
	public int checkState() {
		return mWifiManager.getWifiState();
	}

	// 锁定wifiLock
	public void acquireWifiLock() {
		mWifiLock.acquire();
	}

	// 解锁wifiLock
	public void releaseWifiLock() {
		// 判断是否锁定
		if (mWifiLock.isHeld()) {
			mWifiLock.acquire();
		}
	}

	// 创建一个wifiLock
	public void createWifiLock() {
		mWifiLock = mWifiManager.createWifiLock("test");
	}

	// 得到配置好的网络
	public ArrayList<WifiConfiguration> getConfiguration() {
		return mWifiConfigurations;
	}

	// 指定配置好的网络进行连接
	public void connetionConfiguration(int index) {
		if (index > mWifiConfigurations.size()) {
			return;
		}
		// 连接配置好指定ID的网络
		mWifiManager.enableNetwork(mWifiConfigurations.get(index).networkId,
				true);
	}

	public void startScan() {
		mWifiManager.startScan();
		// 得到扫描结果
		mWifiList = mWifiManager.getScanResults();
		// 得到配置好的网络连接,即所有附近可用的网络
		mWifiConfigurations = (ArrayList<WifiConfiguration>) mWifiManager
				.getConfiguredNetworks();
	}

	// 得到网络列表
	public List<ScanResult> getWifiList() {
		return mWifiList;
	}

	// 查看扫描结果
	public StringBuffer lookUpScan() {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < mWifiList.size(); i++) {
			sb.append("Index_" + new Integer(i + 1).toString() + ":");
			// 将ScanResult信息转换成一个字符串包
			// 其中把包括：BSSID、SSID、capabilities、frequency、level
			sb.append((mWifiList.get(i)).toString()).append("\n");
		}
		return sb;
	}

	public String getMacAddress() {
		return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
	}

	public String getBSSID() {
		return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();
	}

	public int getIpAddress() {
		return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
	}

	// 得到连接的ID
	public int getNetWordId() {
		return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
	}

	// 得到wifiInfo的所有信息
	public String getWifiInfo() {
		return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
	}

	// 添加一个网络并连接
	public void addNetWork(WifiConfiguration configuration) {
		int wcgId = mWifiManager.addNetwork(configuration);
		mWifiManager.enableNetwork(wcgId, true);
	}

	// 断开指定ID的网络
	public void disConnectionWifi(int netId) {
		mWifiManager.disableNetwork(netId);
		mWifiManager.disconnect();
	}

	/**
	 * 根据输入的SSID,密码，类型创建一个连接
	 * 
	 * @param SSID
	 * @param password
	 * @param type
	 */
	public void connect(String SSID, String password, WifiCipherType type) {

		WifiConfiguration wifiConfig = createWifiInfo(SSID, password, type);
		addNetWork(wifiConfig);
	}

	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.equals(WifiCipherType.WIFICIPHER_NOPASS)) {
			config.wepKeys[0] = "";
			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
			config.wepTxKeyIndex = 0;
		}
		if (type.equals(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.equals(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;
	}

	// 定义几种加密方式，一种是WEP，一种是WPA，还有没有密码的情况
	public enum WifiCipherType {
		WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
	}

	/**
	 * 开启wifi热点
	 */
	public void startWifiAp(String ssid, String password) {

		Method method = null;
		try {

			closeWifi();　//因为热点与wifi连接是不可同时启用的，所以打开热点前要关闭wifi
			method = mWifiManager.getClass().getMethod("setWifiApEnabled",
					WifiConfiguration.class, boolean.class);
			WifiConfiguration netConfig = new WifiConfiguration();
			netConfig.SSID = ssid;
			netConfig.preSharedKey =  password;
			netConfig.allowedAuthAlgorithms
					.set(WifiConfiguration.AuthAlgorithm.OPEN);
			netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
			netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
			netConfig.allowedKeyManagement
					.set(WifiConfiguration.KeyMgmt.WPA_PSK);
			netConfig.allowedPairwiseCiphers
					.set(WifiConfiguration.PairwiseCipher.CCMP);
			netConfig.allowedPairwiseCiphers
					.set(WifiConfiguration.PairwiseCipher.TKIP);
			netConfig.allowedGroupCiphers
					.set(WifiConfiguration.GroupCipher.CCMP);
			netConfig.allowedGroupCiphers
					.set(WifiConfiguration.GroupCipher.TKIP);

			method.invoke(mWifiManager, netConfig, true);

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

            /**关闭wifi热点
             public void closeWifiAp(WifiManager wifiManager) {
		 if (isWifiApEnabled(wifiManager)) {
			try {
				Method method = wifiManager.getClass().getMethod(
						"getWifiApConfiguration");
				method.setAccessible(true);

				WifiConfiguration config = (WifiConfiguration) method
						.invoke(wifiManager);

				Method method2 = wifiManager.getClass().getMethod(
						"setWifiApEnabled", WifiConfiguration.class,
						boolean.class);
				method2.invoke(wifiManager, config, false);
			} catch (NoSuchMethodException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

　　　　/**判断手机热点是否可用
	public boolean isWifiApEnabled(WifiManager wifiManager) {
		try {
			Method method = wifiManager.getClass().getMethod("isWifiApEnabled");
			method.setAccessible(true);
			return (Boolean) method.invoke(wifiManager);

		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}

		return false;
	}
}