android wifi热点的创建以及连接通信（华为T8951 Google GALAXY Nexus 测试通过）

2013-06-17 16:44:00 7728 收藏
分类专栏： android 文章标签： Android Google 测试 华为 Wi-Fi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mao520741111/article/details/9112231
版权
android 专栏收录该内容
63 篇文章 0 订阅
订阅专栏

               参考网上的很多的资料，初步实现了wifi热点的创建、连接以及聊天通信，以下是网上广为流传的Wifi 三种配置：

 
  1. 	
  2. 	public WifiConfiguration createWifiInfo(String SSID, String password, int type) {
  3. 		
  4. 		Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);
  5. 		
  6. 		WifiConfiguration config = new WifiConfiguration();
  7. 		config.allowedAuthAlgorithms.clear();
  8. 		config.allowedGroupCiphers.clear();
  9. 		config.allowedKeyManagement.clear();
  10. 		config.allowedPairwiseCiphers.clear();
  11. 		config.allowedProtocols.clear();
  12. 		config.SSID = "\"" + SSID + "\"";
  13.  
  14. 		WifiConfiguration tempConfig = this.IsExsits(SSID);
  15. 		if (tempConfig != null) {
  16. 			mWifiManager.removeNetwork(tempConfig.networkId);
  17. 		}
  18. 		
  19. 		// 分为三种情况：1没有密码2用wep加密3用wpa加密
  20. 		if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS
  21. 			config.wepKeys[0] = "";
  22. 			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  23. 			config.wepTxKeyIndex = 0;
  24. 			
  25. 		} else if (type == TYPE_WEP) {  //  WIFICIPHER_WEP 
  26. 			config.hiddenSSID = true;
  27. 			config.wepKeys[0] = "\"" + password + "\"";
  28. 			config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
  29. 			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  30. 			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  31. 			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
  32. 			config.allowedGroupCiphers
  33. 					.set(WifiConfiguration.GroupCipher.WEP104);
  34. 			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  35. 			config.wepTxKeyIndex = 0;
  36. 		} else if (type == TYPE_WPA) {   // WIFICIPHER_WPA
  37. 			config.preSharedKey = "\"" + password + "\"";
  38. 			config.hiddenSSID = true;
  39. 			config.allowedAuthAlgorithms
  40. 					.set(WifiConfiguration.AuthAlgorithm.OPEN);
  41. 			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  42. 			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
  43. 			config.allowedPairwiseCiphers
  44. 					.set(WifiConfiguration.PairwiseCipher.TKIP);
  45. 			// config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
  46. 			config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  47. 			config.allowedPairwiseCiphers
  48. 					.set(WifiConfiguration.PairwiseCipher.CCMP);
  49. 			config.status = WifiConfiguration.Status.ENABLED;
  50. 		} 
  51. 		
  52. 		return config;
  53. 	}


            wifi热点的创建代码：


  

  1. package com.example.andoidwifihotdemo.wifiadamin;
  2.  
  3.  
  4. import java.lang.reflect.InvocationTargetException;
  5. import java.lang.reflect.Method;
  6.  
  7. import com.example.andoidwifihotdemo.activity.BaseActivity;
  8. import com.example.andoidwifihotdemo.activity.WifiApAdminActivity;
  9. import com.example.andoidwifihotdemo.constant.Global;
  10. import android.content.Context;
  11. import android.net.wifi.WifiConfiguration;
  12. import android.net.wifi.WifiManager;
  13. import android.util.Log;
  14.  
  15. /**
  16.  * 
  17.  * 热点搜索，创建，关闭
  18.  * 
  19.  */
  20. public class WifiApAdmin {
  21. 	
  22. 	public static final String TAG = "WifiApAdmin";
  23. 	private WifiManager mWifiManager = null;
  24. 	private Context mContext = null;
  25. 	private static WifiApAdmin instance;
  26. 	private WifiApAdminActivity wifiApAdminActivity;
  27. 	
  28. 	public void closeWifiAp() {
  29. 		closeWifiAp(mWifiManager);
  30. 	}
  31.  
  32. 	public static WifiApAdmin newInstance(Context context){
  33. 		if(instance==null){
  34. 			instance = new  WifiApAdmin(context);
  35. 		}
  36. 		return instance;
  37. 	}
  38. 	
  39. 	private  WifiApAdmin(Context context) {
  40. 		mContext = context;
  41. 		wifiApAdminActivity = (WifiApAdminActivity)context;
  42. 		mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);  
  43. 		closeWifiAp(mWifiManager);
  44. 	}
  45.  
  46. 	public void startWifiAp() {
  47. 		Log.i(TAG, "into startWifiAp（）");
  48. 		//創建Wifi熱點需要關閉Wifi
  49. 		if (mWifiManager.isWifiEnabled()) {
  50. 			mWifiManager.setWifiEnabled(false);
  51. 		} 
  52. 		stratWifiAp();
  53. 	}
  54.  
  55. 	//啟動一個Wifi 熱點
  56. 	private boolean stratWifiAp() {
  57. 		
  58. 		Log.i(TAG, "into startWifiAp（） 启动一个Wifi 热点！");
  59. 		Method method1 = null;
  60. 		boolean ret = false;
  61. 		try {
  62. 			method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",WifiConfiguration.class, boolean.class);
  63. //          WifiConfiguration netConfig =WifiApConfigurationAdmin.getInstance(mContext).CreateWifiInfo(Global.SSID, Global.SSID, 2);
  64.             //热点的配置类
  65.            	WifiConfiguration apConfig = createPassHotWifiConfig(Global.SSID,Global.PASSWORD);
  66. 			ret = (Boolean) method1.invoke(mWifiManager, apConfig, true);
  67. 		} catch (IllegalArgumentException e) {
  68. 			e.printStackTrace();
  69. 			Log.d(TAG, "stratWifiAp() IllegalArgumentException e");
  70. 		} catch (IllegalAccessException e) {
  71. 			e.printStackTrace();
  72. 			Log.d(TAG, "stratWifiAp() IllegalAccessException e");
  73. 		} catch (InvocationTargetException e) {
  74. 			e.printStackTrace();
  75. 			Log.d(TAG, "stratWifiAp() InvocationTargetException e");
  76. 		} catch (SecurityException e) {
  77. 			e.printStackTrace();
  78. 			Log.d(TAG, "stratWifiAp() SecurityException e");
  79. 		} catch (NoSuchMethodException e) {
  80. 			e.printStackTrace();
  81. 			Log.d(TAG, "stratWifiAp() NoSuchMethodException e");
  82. 		}
  83. 		Log.i(TAG, "out startWifiAp（） 启动一个Wifi 热点！");
  84. 		return ret;
  85. 		
  86. 	}
  87. 	
  88.  
  89. 	//關閉Wifi熱點
  90. 	private  boolean closeWifiAp(WifiManager wifiManager) {
  91.  
  92. 		Log.i(TAG, "into closeWifiAp（） 关闭一个Wifi 热点！");
  93. 		boolean ret =false;
  94. 		if (isWifiApEnabled(wifiManager)) {
  95. 			try {
  96. 				Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");
  97. 				method.setAccessible(true);
  98. 				WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);
  99. 				Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);
  100. 				ret = (Boolean) method2.invoke(wifiManager, config, false);
  101. 			} catch (NoSuchMethodException e) {
  102. 				// TODO Auto-generated catch block
  103. 				e.printStackTrace();
  104. 			} catch (IllegalArgumentException e) {
  105. 				// TODO Auto-generated catch block
  106. 				e.printStackTrace();
  107. 			} catch (IllegalAccessException e) {
  108. 				// TODO Auto-generated catch block
  109. 				e.printStackTrace();
  110. 			} catch (InvocationTargetException e) {
  111. 				// TODO Auto-generated catch block
  112. 				e.printStackTrace();
  113. 			}
  114. 		}
  115. 		Log.i(TAG, "out closeWifiAp（） 关闭一个Wifi 热点！");
  116. 		return ret;
  117. 	}
  118.  
  119. 	//检测Wifi 热点是否可用
  120. 	public  boolean isWifiApEnabled(WifiManager wifiManager) {
  121. 		try {
  122. 			Method method = wifiManager.getClass().getMethod("isWifiApEnabled");
  123. 			method.setAccessible(true);
  124. 			return (Boolean) method.invoke(wifiManager);
  125. 		} catch (NoSuchMethodException e) {
  126. 			e.printStackTrace();
  127. 		} catch (Exception e) {
  128. 			e.printStackTrace();
  129. 		}
  130. 		return false;
  131. 	}
  132. 	
  133. 	//扫描附近可用网络
  134. 	public void startScan(){
  135. 		
  136. 		//wifi 关闭的情况下，取消wifi状态广播监听
  137. 		if(BaseActivity.wifiStatebRoadCast){
  138. 			BaseActivity.wifiStatebRoadCast =false;
  139. 			wifiApAdminActivity.unregisterReceiver(wifiApAdminActivity.connectReceiver);
  140. 		}
  141. 		//搜索热点
  142. 		mWifiManager.startScan();
  143. 	}
  144. }

            以上代码就是网上收集的wifi热点的创建，关闭，检测是否可用，值得说明的是，参照部分大牛的代码，利用android的广播来监听附近wifi热点的扫描：


            IntentFilter intentWifiApoints = new IntentFilter(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION); 加入附近热点的扫描结果，热点扫描代码：

        

           

  1. mWifimanager =(WifiManager)getSystemService(Context.WIFI_SERVICE);
  2. mWifiManager.startScan();

                    广播监听处理，根据SSID来判断附近热点有没有自己需要的连接的热点，然后配置相应的WifiConfiguration 连接Wifi热点：

                       

  1. package com.example.andoidwifihotdemo.receiver;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import com.example.andoidwifihotdemo.activity.BaseActivity;
  6. import com.example.andoidwifihotdemo.activity.WifiApAdminActivity;
  7. import com.example.andoidwifihotdemo.constant.Global;
  8. import com.example.andoidwifihotdemo.wifiadamin.WifiApConfigurationAdmin;
  9.  
  10. import android.content.BroadcastReceiver;
  11. import android.content.Context;
  12. import android.content.Intent;
  13. import android.net.wifi.ScanResult;
  14. import android.net.wifi.WifiConfiguration;
  15. import android.net.wifi.WifiManager;
  16. import android.util.Log;
  17.  
  18. /**
  19.  * 扫描热点，找到符合规格的热点并连接
  20.  * 
  21.  */
  22.  
  23. public class WifiScanRsultBroadCast extends BroadcastReceiver {
  24.  
  25. 	private Context mContext;
  26. 	private WifiApAdminActivity wifiApAdminActivity;
  27. 	private WifiManager mWifimanager;
  28.  
  29. 	private String ssID;
  30. 	
  31. 	private List<WifiConfiguration> configurations = new ArrayList<WifiConfiguration>();
  32. 	 // 网络连接列表  
  33.     private List<WifiConfiguration> mWifiConfiguration; 
  34. 	private List<ScanResult> wifiList;
  35.  
  36.     
  37. 	public WifiScanRsultBroadCast(Context context){
  38. 		
  39. 		this.mContext = context;
  40. 		wifiApAdminActivity = (WifiApAdminActivity)context;
  41. 		
  42. 	}
  43. 	
  44. 	@Override
  45. 	public void onReceive(Context context, Intent intent) {
  46. 		Log.i("WifiBroadCast", "into onReceive(Context context, Intent intent)");
  47. 		if(intent.getAction().equalsIgnoreCase(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)){
  48. 			mWifimanager = BaseActivity.mWifimanager;
  49. 			wifiList = mWifimanager.getScanResults();
  50. 			Log.i("WifiBroadCast", "into onReceive(Context context, Intent intent) wifiList= "+wifiList);
  51. 			if (wifiList == null || wifiList.size() == 0||WifiApAdminActivity.isConnecting){
  52. 				return;
  53. 			}
  54. 			configurations = BaseActivity.mWifimanager.getConfiguredNetworks();
  55. 			for(WifiConfiguration config :configurations){
  56.                 Log.i("WifiBroadCast config pro 优先级", "  "+config.priority+"  config SSID="+config.SSID);	
  57.                 Log.i("WifiBroadCast config statu =", "  "+config.status);	
  58.  			}
  59. 		   onReceiveNewNetworks(wifiList);
  60. 		Log.i("WifiBroadCast", "out onReceive(Context context, Intent intent)");
  61. 	  }
  62.    }
  63. 	
  64. 	
  65. 	/*当搜索到新的wifi热点时判断该热点是否符合规格*/
  66. 	public void onReceiveNewNetworks(List<ScanResult> wifiList){
  67. 	Log.i("WifiBroadCast", "into onReceiveNewNetworks(List<ScanResult> wifiList)");
  68. 	    for(ScanResult result:wifiList){
  69. 	       System.out.println(result.SSID);
  70. 	       if((result.SSID).contains(Global.SSID)){
  71. 	    	   synchronized (this) {
  72. 	    		    ssID =result.SSID;
  73. 	    		    new Thread(new Runnable() {
  74. 						@Override
  75. 						public void run() {
  76. 			    			connectToHotpot();
  77. 						}
  78. 					}).start();
  79. 	    	  }
  80. 	     }
  81. 	 }
  82.   }
  83. 	
  84. 	/*连接到热点*/
  85. 	public void connectToHotpot(){
  86. 		
  87. 		Log.i("WifiBroadCast", "into  connectToHotpot()");
  88. 		if(ssID==null||ssID.equals("")){
  89. 			return;
  90. 		}
  91. 		WifiConfiguration config = WifiApConfigurationAdmin.getInstance(mContext).CreateWifiInfo(ssID,Global.PASSWORD,1);
  92. //		WifiConfiguration config = createConnectWifiConfig();
  93. 		wifiApAdminActivity.enableNetwork(config);
  94. 		Log.i("WifiBroadCast", "out  connectToHotpot()");
  95. 		
  96. 	}
  97. }


               值得提醒的一点是，通过Activity注册wifi热点广播监听时，记得注销掉，个人认为，在出发搜索事件的时候注册，在搜索结束之后应该注销掉，不然后台会一直在跑，自己测试的时候，一直在不停地打log日志，感觉很不好。

wifi热点的连接代码，其实很简单：

  1.                 int wcgID = mWifimanager.addNetwork(wifiConfig);
  2.  		Log.i(TAG, "into enableNetwork(WifiConfiguration wifiConfig) wcID = "+ wcgID);
  3. 		if (wcgID < 0) {
  4. 			Log.i(TAG,"into enableNetwork(WifiConfiguration wifiConfig) addNetWork fail!");
  5. 			 statu.setText("Wifi 热点连接失败！");
  6. 			isConnected = false;
  7.  			return;
  8. 		}
  9. 		 boolean flag = mWifimanager.enableNetwork(wcgID, true);

       个人测试的部分所得是：如果需要连接某一个Wifi热点，必须得先添加网络，根据自己的华为手机测试结果知，一下添加代码的效果就只是将你所指定的热点网络加入到信任区 
   addNetwork(wifiConfig);

           恩，以上所说的绝大部分都是根据网上大牛的代码所得，之下就是自己的一些个人收获：

        其实，wifi热点的创建、关闭了这些东西网上都有现成的代码很是简单，热点能否连接成功才是最关键的地方，而热点连接成功与否的关键应该在于热点创建的WifiConfiguration对象与连接热点时所创建的WifiConfiguration 对象是否匹配上。

             个人对计算机网络很是菜鸟，仅仅就是根据文章最前说的三种配置方式进行对应配置进行测试，过程中发现一些问题，与大家分享一下，希望大家多多指点：

            1.没有密码的配置方式

            A.热点创建端

           

  1. 	               //1.没有任何密码保护
  2. 	       private WifiConfiguration createHotWifiConfig(String mSSID,String mPasswd){
  3. 		
  4. 		WifiConfiguration config = new WifiConfiguration();
  5.    		config.allowedAuthAlgorithms.clear();
  6. 		config.allowedGroupCiphers.clear();
  7. 		 config.allowedKeyManagement.clear();
  8. 		config.allowedPairwiseCiphers.clear();
  9.  		config.allowedProtocols.clear();
  10.  		config.SSID = "" + mSSID + "";
  11.  		
  12. 	        config.wepKeys[0] = "";
  13.   		config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  14. 	        config.wepTxKeyIndex = 0;
  15. 		config.priority=0;
  16. 		return config;
  17. 		
  18. 	}

              B.连接热点端配置

           

  1. 	        WifiConfiguration config = new WifiConfiguration();
  2. 		config.allowedAuthAlgorithms.clear();
  3. 		config.allowedGroupCiphers.clear();
  4. 		config.allowedKeyManagement.clear();
  5. 		config.allowedPairwiseCiphers.clear();
  6. 		config.allowedProtocols.clear();
  7. 		config.SSID = "\"" + SSID + "\"";
  8. 		config.priority=0;
  9. 		
  10. 		IsExsits(SSID);
  11. 		// 分为三种情况：1没有密码2用wep加密3用wpa加密
  12. 		if (type == 1) {// WIFICIPHER_NOPASS
  13. 			
  14. 			config.wepKeys[0] = "\""+""+"\"";
  15. 			config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  16. 			config.wepTxKeyIndex = 0;
  17. 		}

               仔细一看，其实两端的代码基本上是一样的，唯一的差别就是在于 
      config.SSID = "\"" + SSID + "\"";
   

             所以这是个人所得的第一点，在创建热点，以及连接热点时，转义字符千万别搞错了，否则在 addNetWork（wifiConfig）时，返回的NwtWorkID 会一直都是-1，也就是添加网络失败。

        说明ISExsists（String SSID）



  1.      public void IsExsits(String SSID)  
  2.     {  
  3.         mWifiManager = WifiApAdminActivity.mWifimanager;
  4.         String destStr = "\""+SSID+"\"";
  5.         Log.i(TAG, "existingConfig destStr = "+destStr);
  6.         Log.d(TAG, "mWifiManager ="+mWifiManager);
  7.  
  8. //      获取已配置wifi热点网络，通过 addNetwork(wifiConfig)会将连接端自己配置的WifiConfiguration加入到其中;
  9.         List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
  10.         if(existingConfigs==null){
  11.             return;
  12.         }
  13.            for (WifiConfiguration existingConfig : existingConfigs)   
  14.            {  
  15.                  Log.i(TAG, "existingConfig ssid = "+existingConfig.SSID);
  16.              if (existingConfig.SSID.equalsIgnoreCase(destStr))  
  17.              {  
  18.                  Log.i(TAG, "existingConfig contain ssid = "+existingConfig.SSID);
  19.                  mWifiManager.removeNetwork(existingConfig.networkId); 
  20. //                 return existingConfig;  
  21.              }  
  22.            }  
  23. //        return null;   
  24.     }
  25.  
  26.  
  27.  


          
    因为 

 

 

     addNetwork(wifiConfig)
  
 会将wifi热点连接端配置的WifiConfiguration 对象加入信任区中，在每一次连接自己指点的 WifiConfiguration 配置对象之前，需要根据SSID 将信任区中的 WifiConfiguration 对象移除，否侧的话网络会连接不上，这也就是个人所得的第二点，记得移除配置中已经存在的相同wifi热点配置。 

 


 
 

      根据第一种配置方式进行测试，我的华为手机作为客户端连接到 GALAXY  热点是OK的，也可以进行聊天通信，但是如果换过来的话，即我的华为手机作为热点Server端，GALAXY  作为 连接热点客户端的话，就一直失败。
 

     addNetwork(wifiConfig) 方法会一直返回-1，当时自己就很诧异，难道是手机版本的问题，华为手机4.0系统，GALAXY 4.2的系统，自己就换了第二种配置方式：
 


 
 

        2.wep 配置方式
 

    
 
 

      A 热点创建端：
 

    
 

  1. 	
  2.           WifiConfiguration config = new WifiConfiguration();
  3.         config.allowedAuthAlgorithms.clear();
  4.         config.allowedGroupCiphers.clear();
  5.         config.allowedKeyManagement.clear();
  6.         config.allowedPairwiseCiphers.clear();
  7.         config.allowedProtocols.clear();
  8.         config.SSID = "" + SSID + "";
  9.         config.priority=0;
  10.         config.hiddenSSID = true;
  11.         config.wepKeys[0] = "" + password + "";
  12. 	config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
  13. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  14. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  15. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
  16. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
  17. 	config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  18. 	config.wepTxKeyIndex = 0;


 

 

 

       B 热点连接端：
 

      
 

  1.           WifiConfiguration config = new WifiConfiguration();
  2.         config.allowedAuthAlgorithms.clear();
  3.         config.allowedGroupCiphers.clear();
  4.         config.allowedKeyManagement.clear();
  5.         config.allowedPairwiseCiphers.clear();
  6.         config.allowedProtocols.clear();
  7.         config.SSID = "\"" + SSID + "\"";
  8.         config.priority=0;
  9.         config.hiddenSSID = true;
  10.         config.wepKeys[0] = "\"" + password + "\"";
  11.   	config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
  12. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  13. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  14. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
  15. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
  16.  	config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  17.  	config.wepTxKeyIndex = 0;


 

 

 

            使用第二种方式，连接端，GALAXY 在添加网络的时候，不再返回-1，表示网络添加成功，但是连接网络时一直失败。后来仔细看了一下，按照这样的对应配置，热点创建段提示的安全性是 无，然而连接端提示的是 Wep 方式加密，而且出现两个相同SSID的热点网络，一个是热点创建端的，一个是连接端的，很明显两端的配置虽然一样但是，两端根本就是两个不同的热点配置，当然无法连接，哎，没办法了，自己对网络也是那种菜鸟的，自己根本就不会配置，后来自己想到一个问题，按照第二种方式创建的热点时不加密的，那么我可以用第一种的连接端的配置去连接啊，但是GALAXY 添加网络会一直返回-1，呵呵，突然想到，加上转义字符，有可能会行，然后加上了转义字符：得到自己最终的两端配置如下：
 

      A 热点创建段
 


 
 

     
 

  1.          WifiConfiguration config = new WifiConfiguration();
  2.         config.allowedAuthAlgorithms.clear();
  3.         config.allowedGroupCiphers.clear();
  4.         config.allowedKeyManagement.clear();
  5.         config.allowedPairwiseCiphers.clear();
  6.         config.allowedProtocols.clear();
  7.         config.SSID = "" + SSID + "";
  8.         config.priority=0;
  9.         config.hiddenSSID = true;
  10.         config.wepKeys[0] = "" + password + "";
  11. 	config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
  12. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
  13. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
  14. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
  15. 	config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
  16. 	config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  17. 	config.wepTxKeyIndex = 0;


        

 

 

     B 热点连接端配置
 

     
 
 

     
 


 
  1.      WifiConfiguration config = new WifiConfiguration();
  2.     config.allowedAuthAlgorithms.clear();
  3.     config.allowedGroupCiphers.clear();
  4.     config.allowedKeyManagement.clear();
  5.     config.allowedPairwiseCiphers.clear();
  6.     config.allowedProtocols.clear();
  7.     config.SSID = "\"" + SSID + "\"";
  8.     config.priority=0;
  9. 		
  10.     IsExsits(SSID);
  11.     config.wepKeys[0] = "\""+""+"\"";
  12.     config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
  13.     config.wepTxKeyIndex = 0;
  14.     config.status = WifiConfiguration.Status.ENABLED;


 

   
     然后居然就连接成功了，呵呵，连接也很稳定。 

 

       文章开头说到的三种配置方式，1,2种到此，第三种按照1，2中的反向思维进行配置，但是不知道为什么热点还么有创建成功，手机自动重启，而且不是一次两次，只要调用热点创建的代码就会手机重启，是在搞不住。 
 
 

至此，我wifi热点的创建连接说到此，后面一些连接成功否检测，Socket通信的内容，等小弟整理好再加进来。希望大家多多指教，才能好好进步
 
 


 
 

 
 
 


 
 

              
 
 

 
 
 

   参考文章：
 

   Wifi 热点
 
   http://www.oschina.net/question/207975_79027
 
  http://bbs.csdn.net/topics/360190048
 
  http://blog.csdn.net/sasoritattoo/article/details/8285926
 
 
  http://stackoverflow.com/questions/15813767/connect-to-wifi-programmaticly-in-google-android
 
  C 底层源码
   http://www.oschina.net/code/explore/freebsd/contrib/wpa/wpa_supplicant/wps_supplicant.c
 
  百度空间
   http://hi.baidu.com/backwang/item/1f6df08b9cf936ded1f8cd99
 


 
 


 
 


 
 

项目下载地址（小弟赚一点积分）