終於吧WiFi功能搞定了，前後歷時半個多月的時間。進度有些慢。但還是很充實的，搞定一個自己面臨的難題時，那種豁然開朗的感覺，讓人神清氣爽。要不是在公司上班時間，真想大吼一聲！“咱老百姓啊，今兒個真高興。。”

我想愛哥，鴻洋和老郭在此的話，肯定嗤之以鼻，心裡碎碎念：老子搞個妞都沒這麼麻煩。。哈哈。

講一講昨晚的趣事，話說昨晚同窗好友邀我LOL戰鬥個三百回合，我本想拒絕，因為我是愛學習的孩子。後來想一想，勞逸結合才是上上策。於是欣然赴約。進遊戲所有人都秒選，奈何我新號沒啥英雄，所以看到免費英雄裡有我的最愛--阿卡利（我的成名英雄）。只好用她打野。第一局順風順水，成功走上超神之路。可惜第二局我還是被迫選得阿卡利打野，然而竟讓我夥的狗熊質疑我。真是是可忍孰不可忍，叔叔可以忍我不能忍。於是我小宇宙爆發，成功拿下紅藍Buff，以及對方打野兩次人頭後。狗熊感覺他的世界觀崩潰了。開始瘋狂的送人頭，送誰不好偏偏送對方卡特。於是乎，我們的末日來臨了。我方內部開始君子行動，君子動口不動手的原則，不斷的慰問狗熊。我明知的分析，光慰問是贏不了的。所以在我採取敵進我退，敵退我偷的戰略後。距離成神僅一步之遙，然後惜敗。整整30多分鐘，狗熊送了40多人頭。也苦了這孩子了。。。待我收拾妥當準備休息時，隔壁大吼一聲：該出手時就出手啊！！然後就是掀桌子扔板凳緊接著就是噼噼啪啪伴隨著慘叫聲不絕於耳我的第一反應是完了狗熊被人肉了！！（所謂：句讀之不知，惑之不解。我就想看看有多少人看懂了這句話。哈哈）於是幸災樂禍的熄燈睡覺。

閒言少敘，言歸正傳，咱們程式碼說事。

在上一篇文章Android WiFi功能實現，知其然必知其所以然！（一）中，我封裝了幾個WiFi常見處理的方法，詳情請跳轉。但，這裡也要宣告一些問題。對於上一篇文章，WiFi的建立，配置，搜尋，關閉等方法都沒有錯。但一直沒有成功的連結到指定的WiFi或WiFi熱點上。是上一篇懸而未解的疑案。經過我新的一週的不懈努力，終於發現問題所在，最終的問題是出在對WiFi連結的理解上。這裡給大家帶來的不便，盡請諒解。現在重新解釋一下，WiFi熱點，其實也是WiFi。不要把熱點和WiFi區分開，他們的區別在直觀上給我們的印象是，WiFi--比如路由器的無線網路，熱點--比如手機發射的無線訊號。其實他們是沒有區別的。都是WiFi熱點。只不過訊號源有區別罷了。

理解到這裡，那自然一切都明白了，建立手機WiFi熱點，用的是系統提供的建立熱點的API，而熱點也是WiFi，在連結熱點時，其實也就是連結WiFi，那麼，用平時的WiFi連結方法，就一切OK了。（在這之前，由於沒有認真分析這之前的關係，一直以為WiFi是WiFi，熱點是熱點，然後就出現了，在用連結熱點的方法連結熱點時，方法返回連結成功的狀態，而卻一直無法連結，這著實讓我糾結好一陣子。）

接下來，看看程式碼實現。

WifiHotspotUtils.java------WiFi熱點工具類

package com.lizhipeng.wifiHotPoint.activity.utils;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List;

import com.lizhipeng.wifiHotPoint.activity.MainActivity;

import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.util.Log;

/**
 * WiFi熱點工具類
 * 
 * @author lizhipeng
 * 
 */
public class WifiHotspotUtils {

	public static final String TAG = "WifiHotPointUtils";

	public static WifiConfiguration createWifiInfo2(String ssid,
			String password, int paramInt) {
		WifiConfiguration config = new WifiConfiguration();
		config.allowedAuthAlgorithms.clear();
		config.allowedGroupCiphers.clear();
		config.allowedKeyManagement.clear();
		config.allowedPairwiseCiphers.clear();
		config.allowedProtocols.clear();

		config.SSID = ssid;

		if (paramInt == 1) // WIFICIPHER_NOPASS 不加密
		{
			config.wepKeys[0] = "";
			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
			config.wepTxKeyIndex = 0;
			return config;
		}
		if (paramInt == 2) // WIFICIPHER_WEP 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;
			return config;
		}
		if (paramInt == 3) // WIFICIPHER_WPA 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;
		}
		return null;// 返回null，建立熱點失敗
	}

	/**
	 * 建立WiFi熱點
	 * @param wifiManager WiFi管理器
	 * @param config WiFi配置資訊
	 * @param paramBoolean true為開啟WiFi熱點，false為關閉
	 * @return 返回開啟成功狀態，true為成功，false為失敗
	 */
	public static boolean createWiFiAP(WifiManager wifiManager,WifiConfiguration config, boolean paramBoolean) {
		// 開啟熱點前，如果WiFi可用，先關閉WiFi  
        if (wifiManager.isWifiEnabled()) {  
            wifiManager.setWifiEnabled(false);  
        }  
        Log.i(TAG, "into startWifiAp（） 啟動一個Wifi 熱點！");  
        boolean ret = false;  
        try {  
        	Method method = wifiManager.getClass().getMethod("setWifiApEnabled",  
                    WifiConfiguration.class, boolean.class);
            ret = (Boolean) method.invoke(wifiManager, config, paramBoolean);  
        } catch (IllegalArgumentException e) {  
            e.printStackTrace();  
            Log.d(TAG, "stratWifiAp() IllegalArgumentException e");  
        } catch (IllegalAccessException e) {  
            e.printStackTrace();  
            Log.d(TAG, "stratWifiAp() IllegalAccessException e");  
        } catch (InvocationTargetException e) {  
            e.printStackTrace();  
            Log.d(TAG, "stratWifiAp() InvocationTargetException e");  
        } catch (SecurityException e) {  
            e.printStackTrace();  
            Log.d(TAG, "stratWifiAp() SecurityException e");  
        } catch (NoSuchMethodException e) {  
            e.printStackTrace();  
            Log.d(TAG, "stratWifiAp() NoSuchMethodException e");  
        }  
        Log.i(TAG, "out startWifiAp（） 啟動一個Wifi 熱點！");  
        return ret;  
    }
	
	/**
	 * 配置WiFi或者熱點資訊
	 * 
	 * @param wifiManager
	 *            WiFi管理器
	 * @param ssid
	 *            WiFi名稱
	 * @param password
	 *            WiFi密碼
	 * @param paramInt
	 *            WiFi加密方式 1為不加密，2為WEP加密，3為wpa加密
	 * @param wifiType
	 *            “wifi”為開啟普通WiFi連線，“ap”為建立WiFi熱點
	 * @return
	 */
	public static WifiConfiguration createWifiInfo(WifiManager wifiManager,
			String ssid, String password, int paramInt, String wifiType) {
		WifiConfiguration Config1 = new WifiConfiguration();
		Config1.allowedAuthAlgorithms.clear();
		Config1.allowedGroupCiphers.clear();
		Config1.allowedKeyManagement.clear();
		Config1.allowedPairwiseCiphers.clear();
		Config1.allowedProtocols.clear();
		if ("wifi".equals(wifiType)) {
			Config1.SSID = ("\"" + ssid + "\"");
			WifiConfiguration Config2 = isExsits(wifiManager, ssid);
			if (Config2 != null) {
				if (wifiManager != null) {
					wifiManager.removeNetwork(Config2.networkId);
				}
			}
			if (paramInt == 1) {
				Config1.wepKeys[0] = "";
				Config1.allowedKeyManagement.set(0);
				Config1.wepTxKeyIndex = 0;
				return Config1;
			} else if (paramInt == 2) {
				Config1.hiddenSSID = true;
				Config1.wepKeys[0] = ("\"" + password + "\"");
				return Config1;
			} else {
				Config1.preSharedKey = ("\"" + password + "\"");
				Config1.hiddenSSID = true;
				Config1.allowedAuthAlgorithms.set(0);
				Config1.allowedGroupCiphers.set(2);
				Config1.allowedKeyManagement.set(1);
				Config1.allowedPairwiseCiphers.set(1);
				Config1.allowedGroupCiphers.set(3);
				Config1.allowedPairwiseCiphers.set(2);
				return Config1;
			}
		} else {
			WifiConfiguration wifiApConfig = new WifiConfiguration();
			wifiApConfig.allowedAuthAlgorithms.clear();
			wifiApConfig.allowedGroupCiphers.clear();
			wifiApConfig.allowedKeyManagement.clear();
			wifiApConfig.allowedPairwiseCiphers.clear();
			wifiApConfig.allowedProtocols.clear();

			wifiApConfig.SSID = ssid;

			if (paramInt == 1) // WIFICIPHER_NOPASS 不加密
			{
				wifiApConfig.wepKeys[0] = "";
				wifiApConfig.allowedKeyManagement
						.set(WifiConfiguration.KeyMgmt.NONE);
				wifiApConfig.wepTxKeyIndex = 0;
				return wifiApConfig;
			}
			if (paramInt == 2) // WIFICIPHER_WEP WEP加密
			{
				wifiApConfig.hiddenSSID = true;
				wifiApConfig.wepKeys[0] = password;
				wifiApConfig.allowedAuthAlgorithms
						.set(WifiConfiguration.AuthAlgorithm.SHARED);
				wifiApConfig.allowedGroupCiphers
						.set(WifiConfiguration.GroupCipher.CCMP);
				wifiApConfig.allowedGroupCiphers
						.set(WifiConfiguration.GroupCipher.TKIP);
				wifiApConfig.allowedGroupCiphers
						.set(WifiConfiguration.GroupCipher.WEP40);
				wifiApConfig.allowedGroupCiphers
						.set(WifiConfiguration.GroupCipher.WEP104);
				wifiApConfig.allowedKeyManagement
						.set(WifiConfiguration.KeyMgmt.NONE);
				wifiApConfig.wepTxKeyIndex = 0;
				return wifiApConfig;
			}
			if (paramInt == 3) // WIFICIPHER_WPA wpa加密
			{
				wifiApConfig.preSharedKey = password;
				wifiApConfig.hiddenSSID = true;
				wifiApConfig.allowedAuthAlgorithms
						.set(WifiConfiguration.AuthAlgorithm.OPEN);
				wifiApConfig.allowedGroupCiphers
						.set(WifiConfiguration.GroupCipher.TKIP);
				wifiApConfig.allowedKeyManagement
						.set(WifiConfiguration.KeyMgmt.WPA_PSK);
				wifiApConfig.allowedPairwiseCiphers
						.set(WifiConfiguration.PairwiseCipher.TKIP);
				// config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
				wifiApConfig.allowedGroupCiphers
						.set(WifiConfiguration.GroupCipher.CCMP);
				wifiApConfig.allowedPairwiseCiphers
						.set(WifiConfiguration.PairwiseCipher.CCMP);
				wifiApConfig.status = WifiConfiguration.Status.ENABLED;
				return wifiApConfig;
			}
		}
		return null;
	}

	/**
	 * 連線WiFi熱點
	 * 
	 * @param wifiManager
	 *            WiFi管理器
	 * @param wifiConfig
	 *            需要連線的WiFi網路的配置物件
	 * @return 返回WiFi熱點是否連線成功
	 */
	public static boolean connectHotspot(WifiManager wifiManager,
			WifiConfiguration wifiConfig) {
		Log.i(TAG, "into enableNetwork(WifiConfiguration wifiConfig)");

		// 新建立的網路配置的id
		int wcgID = wifiManager.addNetwork(wifiConfig);
		Log.i(TAG, "into enableNetwork(WifiConfiguration wifiConfig) wcID = "
				+ wcgID);

		if (wcgID < 0) {
			return false;
		}
		Log.i(TAG, "out enableNetwork(WifiConfiguration wifiConfig)");
		return wifiManager.enableNetwork(wcgID, true);

	}

	/**
	 * 利用反射，呼叫WiFi熱點連結方法
	 * 
	 * @param wifiManager
	 * @param wifiName
	 *            熱點名
	 * @param password
	 *            熱點密碼
	 * @return
	 */
	public static boolean connectHotPointForReflect(WifiManager wifiManager,
			String wifiName, String password) {
		Method getWifiConfig;
		WifiConfiguration myConfig;
		try {
			getWifiConfig = wifiManager.getClass().getMethod(
					"getWifiApConfiguration", null);

			myConfig = (WifiConfiguration) getWifiConfig.invoke(wifiManager,
					null);

			myConfig.SSID = "\"" + wifiName + "\"";
			myConfig.preSharedKey = "\"" + password + "\"";

			Method setWifiConfig = wifiManager.getClass().getMethod(
					"setWifiApConfiguration", WifiConfiguration.class);
			setWifiConfig.invoke(wifiManager, new Object[] { myConfig, true });

			Method enableWifi = wifiManager.getClass().getMethod(
					"setWifiApEnabled", WifiConfiguration.class, boolean.class);
			enableWifi.invoke(wifiManager, null, false);
			WifiConfiguration newConfiguration = (WifiConfiguration) wifiManager
					.getClass().getMethod("getWifiApConfiguration", null)
					.invoke(wifiManager, null);
			return (Boolean) enableWifi.invoke(wifiManager, newConfiguration,
					true);
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		}

	}

	public static boolean connectHotPointForReflect2(WifiManager wifiManager,
			WifiConfiguration wifiConfig) {
		try {
			Method enableWifi = wifiManager.getClass().getMethod(
					"setWifiApEnabled", WifiConfiguration.class, boolean.class);
			enableWifi.invoke(wifiManager, null, false);
			return (Boolean) enableWifi.invoke(wifiManager, wifiConfig, true);
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return false;
		}

	}

	/**
	 * 關閉WiFi熱點
	 * 
	 * @param wifiManager
	 *            WiFi管理器
	 * @return 返回關閉狀態
	 */
	public static boolean closeWifiHotPoint(WifiManager wifiManager) {
		Log.i(TAG, "into closeWifiAp（） 關閉一個Wifi 熱點！");
		boolean ret = false;
		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);
				ret = (Boolean) 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();
			}
		}
		Log.i(TAG, "out closeWifiAp（） 關閉一個Wifi 熱點！");
		return ret;
	}

	/**
	 * 檢測WiFi熱點是否可用
	 * 
	 * @param wifiManager
	 *            WiFi管理器
	 * @return 是否可用狀態
	 */
	public static boolean isWifiApEnabled(WifiManager wifiManager) {
		try {
			Method method = wifiManager.getClass().getMethod("isWifiApEnabled");
			method.setAccessible(true);
			return (Boolean) method.invoke(wifiManager);
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 通過反射，獲取WiFi熱點名稱 SSID
	 * 
	 * @param wifiManager
	 * @return
	 */
	public static String getApSSID(WifiManager wifiManager) {
		try {
			Method localMethod = wifiManager.getClass().getDeclaredMethod(
					"getWifiApConfiguration", new Class[0]);
			if (localMethod == null)
				return null;
			Object localObject1 = localMethod
					.invoke(wifiManager, new Object[0]);
			if (localObject1 == null)
				return null;
			WifiConfiguration localWifiConfiguration = (WifiConfiguration) localObject1;
			if (localWifiConfiguration.SSID != null)
				return localWifiConfiguration.SSID;
			Field localField1 = WifiConfiguration.class
					.getDeclaredField("mWifiApProfile");
			if (localField1 == null)
				return null;
			localField1.setAccessible(true);
			Object localObject2 = localField1.get(localWifiConfiguration);
			localField1.setAccessible(false);
			if (localObject2 == null)
				return null;
			Field localField2 = localObject2.getClass()
					.getDeclaredField("SSID");
			localField2.setAccessible(true);
			Object localObject3 = localField2.get(localObject2);
			if (localObject3 == null)
				return null;
			localField2.setAccessible(false);
			String str = (String) localObject3;
			return str;
		} catch (Exception localException) {
		}
		return null;
	}

	/**
	 * 獲取WiFi熱點的狀態
	 * 
	 * @param wifiManager
	 *            WiFi管理器
	 * @return
	 */
	public int getWifiApState(WifiManager wifiManager) {
		try {
			int i = ((Integer) wifiManager.getClass()
					.getMethod("getWifiApState", new Class[0])
					.invoke(wifiManager, new Object[0])).intValue();
			return i;
		} catch (Exception localException) {
		}
		return 4; // 未知wifi網絡卡狀態
	}

	/**
	 * 判斷選擇的WiFi熱點是否可以連線
	 * 
	 * @param ssid
	 *            WiFi熱點名 SSID
	 * @param wifiList
	 *            附近的WiFi列表
	 * @return true 可以連線 false 不可以連線（不在範圍內）
	 */
	public static boolean checkCoonectHotIsEnable(String ssid,
			List<ScanResult> wifiList) {
		for (ScanResult result : wifiList) {
			if (result.SSID.equals(ssid)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 檢查wifi列表中是否有以輸入引數為名的wifi熱點，如果存在，則在開始配置wifi網路之前將其移除，以避免ssid的重複
	 * 
	 * @param wifiManager
	 * @param SSID
	 * @return
	 */
	private static WifiConfiguration isExsits(WifiManager wifiManager,
			String paramString) {
		Iterator<WifiConfiguration> localIterator = wifiManager
				.getConfiguredNetworks().iterator();
		WifiConfiguration localWifiConfiguration;
		do {
			if (!localIterator.hasNext())
				return null;
			localWifiConfiguration = (WifiConfiguration) localIterator.next();
		} while (!localWifiConfiguration.SSID.equals("\"" + paramString + "\""));
		return localWifiConfiguration;
	}

	public static List<WifiConfiguration> getWifiConfigurations(
			WifiManager wifiManager) {
		List<WifiConfiguration> existingConfigs = wifiManager
				.getConfiguredNetworks();
		return existingConfigs;
	}

}
 

package com.lizhipeng.wifiHotPoint.activity;

import java.util.List;

import com.common.holderandadapter.CommonAdapter;
import com.example.wifipointdemo.R;
import com.lizhipeng.wifiHotPoint.activity.utils.WiFiUtil;
import com.lizhipeng.wifiHotPoint.activity.utils.WifiHotspotUtils;

import android.app.Activity;
import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Button;
import android.widget.ListView;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener ,OnItemClickListener{

	private Button mCreateWifiButton;
	private Button mSearchWifiButton;
	private ListView mWifiListView;
	private List<ScanResult> mWifiInfos;
	private WifiManager mWifiManager;
	private WifiConfiguration configuration;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main_activity);
		
		initView();// 初始化元件
		initData();// 初始化資料
	}

	private void initData() {
		mCreateWifiButton.setOnClickListener(this);
		mSearchWifiButton.setOnClickListener(this);
		mWifiListView.setOnItemClickListener(this);
	}

	private void initView() {
		mWifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
		mCreateWifiButton = (Button) findViewById(R.id.main_activity_btn_create);
		mSearchWifiButton = (Button) findViewById(R.id.main_activity_btn_search);
		mWifiListView = (ListView) findViewById(R.id.main_activity_lv_wifi);
	}

	@Override
	public void onClick(View v) {
		switch (v.getId()) {
		case R.id.main_activity_btn_create:// 點選建立WiFi熱點按鈕
			
			configuration = WifiHotspotUtils.createWifiInfo(mWifiManager, "li-----", "12345678", 3, "ap");
			boolean res = WifiHotspotUtils.createWiFiAP(mWifiManager, configuration, true);
			if (!res) {
				Toast.makeText(this, "WiFi熱點建立失敗", Toast.LENGTH_SHORT).show();
			}else {
				Toast.makeText(this, "WiFi熱點建立成功", Toast.LENGTH_SHORT).show();
			}
			
			break;
		case R.id.main_activity_btn_search:// 點選搜尋WiFi按鈕
			WifiHotspotUtils.closeWifiHotPoint(mWifiManager);//連線前，先關閉WiFi熱點
			WiFiUtil.OpenWifi(mWifiManager);//開啟WiFi
			
			mWifiInfos = WiFiUtil.getWifiList(mWifiManager);

			mWifiListView.setAdapter(new MyAdapter(this, mWifiInfos,R.layout.item_wifi_listview));
//			mWifiListView.setAdapter(new MyAdapter(this, WifiHotPointUtils.getWifiConfigurations(mWifiManager),R.layout.item_wifi_listview));
			break;

		default:
			break;
		}
	}

	class MyAdapter extends CommonAdapter<ScanResult> {

		public MyAdapter(Context context, List<ScanResult> mDatas,
				int itemLayoutId) {
			super(context, mDatas, itemLayoutId);
		}

		@Override
		public void convert(ViewHolder helper, ScanResult item) {
			helper.setText(R.id.item_wifi_listview_tv, item.toString());
		}

	}

	@Override
	public void onItemClick(AdapterView<?> parent, View view, int position,
			long id) {
		
		
		ScanResult scanResult = mWifiInfos.get(position);
		String ssid = scanResult.SSID;
		
		WifiConfiguration config = WifiHotspotUtils.createWifiInfo(mWifiManager, ssid, "12345678", 3, "wifi");
		
		boolean result = WifiHotspotUtils.connectHotspot(mWifiManager, config);
		
		if (result) {
			Toast.makeText(this, ssid+"WiFi熱點連線成功"+position, Toast.LENGTH_SHORT).show();
		} else {
			Toast.makeText(this, ssid+"WiFi熱點連線失敗"+position, Toast.LENGTH_SHORT).show();
		}
	}
}

WifiConfiguration configuration = WifiHotspotUtils.createWifiInfo(mWifiManager, "li-----", "12345678", 3, "ap");
			boolean res = WifiHotspotUtils.createWiFiAP(mWifiManager, configuration, true);

		WifiConfiguration config = WifiHotspotUtils.createWifiInfo(mWifiManager, ssid, "12345678", 3, "wifi");
		
		boolean result = WifiHotspotUtils.connectHotspot(mWifiManager, config);

介面也很簡單

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="38dp"
        android:background="@color/lightcyan"
        android:orientation="horizontal" >

        <ImageButton
            android:id="@+id/main_activity_ib_left_back"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />

        <TextView
            android:id="@+id/main_activity_tv_tittle"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:gravity="center"
            android:text="手機熱點" />

        <ImageButton
            android:id="@+id/main_activity_ib_right_scan"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content" />
    </LinearLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal" >

        <Button
            android:id="@+id/main_activity_btn_create"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="建立熱點" />

        <Button
            android:id="@+id/main_activity_btn_search"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="搜尋熱點" />
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="點選熱點進行連線" />
    </LinearLayout>

    <ListView
        android:id="@+id/main_activity_lv_wifi"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" >
    </ListView>

</LinearLayout>

package com.common.holderandadapter;

import java.util.List;  

import android.content.Context;  
import android.graphics.Bitmap;
import android.util.SparseArray;
import android.view.LayoutInflater;  
import android.view.View;  
import android.view.ViewGroup;  
import android.widget.BaseAdapter;  
import android.widget.ImageView;
import android.widget.TextView;
/**
 * 特別牛逼的Adapter
 * @author lizhipeng
 *
 * @param <T>
 */
public abstract class CommonAdapter<T> extends BaseAdapter  
{  
    protected LayoutInflater mInflater;  
    protected Context mContext;  
    protected List<T> mDatas;  
    protected final int mItemLayoutId;  
  
    public CommonAdapter(Context context, List<T> mDatas, int itemLayoutId)  
    {  
        this.mContext = context;  
        this.mInflater = LayoutInflater.from(mContext);  
        this.mDatas = mDatas;  
        this.mItemLayoutId = itemLayoutId;  
    }  
  
    @Override  
    public int getCount()  
    {  
        return mDatas.size();  
    }  
  
    @Override  
    public T getItem(int position)  
    {  
        return mDatas.get(position);  
    }  
  
    @Override  
    public long getItemId(int position)  
    {  
        return position;  
    }  
  
    @Override  
    public View getView(int position, View convertView, ViewGroup parent)  
    {  
        final ViewHolder viewHolder = getViewHolder(position, convertView,  
                parent);  
        convert(viewHolder, getItem(position));  
        return viewHolder.getConvertView();  
  
    }  
  
    public abstract void convert(ViewHolder helper, T item);  
  
    private ViewHolder getViewHolder(int position, View convertView,  
            ViewGroup parent)  
    {  
        return ViewHolder.get(mContext, convertView, parent, mItemLayoutId,  
                position);  
    }  
    
    public static class ViewHolder  
    {  
        private final SparseArray<View> mViews;  
        private int mPosition;  
        private View mConvertView;  
        /**
         * ViewHolder 的建構函式
         * @param context 上下文
         * @param parent 父佈局
         * @param layoutId 填充的佈局ID
         * @param position item 的位置
         */
        private ViewHolder(Context context, ViewGroup parent, int layoutId,  
                int position)  
        {  
            this.mPosition = position;  
            this.mViews = new SparseArray<View>();  
            mConvertView = LayoutInflater.from(context).inflate(layoutId, parent,  
                    false);  
            // setTag  
            mConvertView.setTag(this);  
        }  
      
        /** 
         * 拿到一個ViewHolder物件 
         *  
         * @param context 上下文
         * @param convertView 複用的View
         * @param parent 父View
         * @param layoutId 佈局檔案ID
         * @param position item 的位置
         * @return 
         */  
        public static ViewHolder get(Context context, View convertView,  
                ViewGroup parent, int layoutId, int position)  
        {  
            if (convertView == null)  
            {  
                return new ViewHolder(context, parent, layoutId, position);  
            }  
            return (ViewHolder) convertView.getTag();  
        }  
      
        public View getConvertView()  
        {  
            return mConvertView;  
        }  
      
        /** 
         * 通過控制元件的Id獲取對於的控制元件，如果沒有則加入views 
         *  
         * @param viewId 
         * @return 返回View
         */  
        public <T extends View> T getView(int viewId)  
        {  
            View view = mViews.get(viewId);  
            if (view == null)  
            {  
                view = mConvertView.findViewById(viewId);  
                mViews.put(viewId, view);  
            }  
            return (T) view;  
        }  
      
        /** 
         * 為TextView設定字串 
         *  
         * @param viewId 
         * @param text 
         * @return 
         */  
        public ViewHolder setText(int viewId, String text)  
        {  
            TextView view = getView(viewId);  
            view.setText(text);  
            return this;  
        }  
      
        /** 
         * 為ImageView設定圖片 
         *  
         * @param viewId 
         * @param drawableId 
         * @return 
         */  
        public ViewHolder setImageResource(int viewId, int drawableId)  
        {  
            ImageView view = getView(viewId);  
            view.setImageResource(drawableId);  
      
            return this;  
        }  
      
        /** 
         * 為ImageView設定圖片 
         *  
         * @param viewId 
         * @param drawableId 
         * @return 
         */  
        public ViewHolder setImageBitmap(int viewId, Bitmap bm)  
        {  
            ImageView view = getView(viewId);  
            view.setImageBitmap(bm);  
            return this;  
        }  
      
        /**
         * 當前的位置
         * @return
         */
        public int getPosition()  
        {  
            return mPosition;  
        }  
      
    }  
  
}  

下次給大家分享基於WiFi的通訊實現。欲知後事如何，請聽下回分解！

轉載請註明出處。