Android 连接Wifi和创建Wifi热点 demo

[java] view
plaincopy

  1. android的热点功能不可见，用了反射的技术搞定之外。  

[java] view
plaincopy

  1. Eclipse设置语言为utf-8才能查看中文注释  

上代码：

MainActivity.java

[java] view
plaincopy

  1. package com.widget.hotspot;  
  2.   
  3. import android.os.Bundle;  
  4. import android.app.Activity;  
  5. import android.content.BroadcastReceiver;  
  6. import android.content.Context;  
  7. import android.content.Intent;  
  8. import android.content.IntentFilter;  
  9. import android.util.Log;  
  10. import android.view.Menu;  
  11. import android.view.View;  
  12. import android.widget.Button;  
  13.   
  14. public class MainActivity extends Activity {  
  15.   
  16.     public static final String TAG = "MainActivity";  
  17.       
  18.     private Button mBtn1, mBtn2;  
  19.       
  20.     private WifiAdmin mWifiAdmin;  
  21.       
  22.     private Context mContext = null;  
  23.     @Override  
  24.     protected void onCreate(Bundle savedInstanceState) {  
  25.         super.onCreate(savedInstanceState);  
  26.           
  27.         mContext = this;  
  28.           
  29.         setContentView(R.layout.activity_main);  
  30.           
  31.         mBtn1 = (Button)findViewById(R.id.button1);  
  32.         mBtn2 = (Button)findViewById(R.id.button2);  
  33.         mBtn1.setText("点击连接Wifi");  
  34.         mBtn2.setText("点击创建Wifi热点");  
  35.         mBtn1.setOnClickListener(new Button.OnClickListener() {  
  36.               
  37.             @Override  
  38.             public void onClick(View v) {  
  39.                 // TODO Auto-generated method stub  
  40.   
  41.                 mWifiAdmin = new WifiAdmin(mContext) {  
  42.                       
  43.                     @Override  
  44.                     public void myUnregisterReceiver(BroadcastReceiver receiver) {  
  45.                         // TODO Auto-generated method stub  
  46.                         MainActivity.this.unregisterReceiver(receiver);  
  47.                     }  
  48.                       
  49.                     @Override  
  50.                     public Intent myRegisterReceiver(BroadcastReceiver receiver,  
  51.                             IntentFilter filter) {  
  52.                         // TODO Auto-generated method stub  
  53.                         MainActivity.this.registerReceiver(receiver, filter);  
  54.                         return null;  
  55.                     }  
  56.                       
  57.                     @Override  
  58.                     public void onNotifyWifiConnected() {  
  59.                         // TODO Auto-generated method stub  
  60.                         Log.v(TAG, "have connected success!");  
  61.                         Log.v(TAG, "###############################");  
  62.                     }  
  63.                       
  64.                     @Override  
  65.                     public void onNotifyWifiConnectFailed() {  
  66.                         // TODO Auto-generated method stub  
  67.                         Log.v(TAG, "have connected failed!");  
  68.                         Log.v(TAG, "###############################");  
  69.                     }  
  70.                 };  
  71.                 mWifiAdmin.openWifi();  
  72.                 mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI", "MM123456", WifiAdmin.TYPE_WPA));  
  73.                   
  74.             }  
  75.         });  
  76.           
  77.         mBtn2.setOnClickListener(new Button.OnClickListener() {  
  78.               
  79.             @Override  
  80.             public void onClick(View v) {  
  81.                 // TODO Auto-generated method stub  
  82.                   
  83.                 WifiApAdmin wifiAp = new WifiApAdmin(mContext);  
  84.                 wifiAp.startWifiAp("\"HotSpot\"", "hhhhhh123");  
  85.             }  
  86.         });  
  87.           
  88.     }  
  89.   
  90.     @Override  
  91.     public boolean onCreateOptionsMenu(Menu menu) {  
  92.         // Inflate the menu; this adds items to the action bar if it is present.  
  93.         getMenuInflater().inflate(R.menu.activity_main, menu);  
  94.         return true;  
  95.     }  
  96.   
  97.      @Override  
  98.         public void onResume() {  
  99.             super.onResume();  
  100.               
  101.             Log.d("Rssi", "Registered");  
  102.         }  
  103.   
  104.         @Override  
  105.         public void onPause() {  
  106.             super.onPause();  
  107.               
  108.             Log.d("Rssi", "Unregistered");  
  109.         }  
  110.       
  111. }  

WifiAdmin.java

参考了：//http://blog.csdn.net/yuanbohx/article/details/8109042

[java] view
plaincopy

  1. package com.widget.hotspot;  
  2.   
  3. import java.util.List;  
  4. import java.util.Timer;  
  5. import java.util.TimerTask;  
  6. import android.content.BroadcastReceiver;  
  7. import android.content.Context;  
  8. import android.content.Intent;  
  9. import android.content.IntentFilter;  
  10. import android.net.ConnectivityManager;  
  11. import android.net.NetworkInfo;  
  12. import android.net.NetworkInfo.DetailedState;  
  13. import android.net.wifi.ScanResult;  
  14. import android.net.wifi.WifiConfiguration;  
  15. import android.net.wifi.WifiInfo;  
  16. import android.net.wifi.WifiManager;  
  17. import android.net.wifi.WifiManager.WifiLock;  
  18. import android.util.Log;  
  19.   
  20.   
  21. public abstract class WifiAdmin {  
  22.       
  23.     private static final String TAG = "WifiAdmin";  
  24.       
  25.     private WifiManager mWifiManager;  
  26.     private WifiInfo mWifiInfo;  
  27.     // 扫描出的网络连接列表  
  28.     private List<ScanResult> mWifiList;  
  29.     private List<WifiConfiguration> mWifiConfiguration;  
  30.   
  31.     private WifiLock mWifiLock;  
  32.       
  33.     private String mPasswd = "";  
  34.     private String mSSID = "";  
  35.       
  36.     private Context mContext = null;  
  37.   
  38.     public WifiAdmin(Context context) {  
  39.           
  40.         mContext = context;  
  41.           
  42.         // 取得WifiManager对象  
  43.         mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);  
  44.         // 取得WifiInfo对象  
  45.         mWifiInfo = mWifiManager.getConnectionInfo();  
  46.           
  47.         Log.v(TAG, "getIpAddress = " + mWifiInfo.getIpAddress());  
  48.     }  
  49.   
  50.     // 打开WIFI  
  51.     public void openWifi() {  
  52.         if (!mWifiManager.isWifiEnabled()) {  
  53.             mWifiManager.setWifiEnabled(true);  
  54.         }  
  55.     }  
  56.   
  57.     // 关闭WIFI  
  58.     public void closeWifi() {  
  59.         if (mWifiManager.isWifiEnabled()) {  
  60.             mWifiManager.setWifiEnabled(false);  
  61.         }  
  62.     }  
  63.   
  64.     public abstract Intent myRegisterReceiver(BroadcastReceiver receiver, IntentFilter filter);  
  65.       
  66.     public abstract void myUnregisterReceiver(BroadcastReceiver receiver);  
  67.       
  68.     public abstract void onNotifyWifiConnected();  
  69.       
  70.     public abstract void onNotifyWifiConnectFailed();  
  71.       
  72.     // 添加一个网络并连接  
  73.     public void addNetwork(WifiConfiguration wcg) {  
  74.           
  75.         register();  
  76.           
  77.         WifiApAdmin.closeWifiAp(mContext);  
  78.           
  79.         int wcgID = mWifiManager.addNetwork(wcg);  
  80.         boolean b = mWifiManager.enableNetwork(wcgID, true);  
  81.     }  
  82.       
  83.     public static final int TYPE_NO_PASSWD = 0x11;  
  84.     public static final int TYPE_WEP = 0x12;  
  85.     public static final int TYPE_WPA = 0x13;  
  86.       
  87.     public void addNetwork(String ssid, String passwd, int type) {  
  88.         if (ssid == null || passwd == null || ssid.equals("")) {  
  89.             Log.e(TAG, "addNetwork() ## nullpointer error!");  
  90.             return;  
  91.         }  
  92.           
  93.         if (type != TYPE_NO_PASSWD && type != TYPE_WEP && type != TYPE_WPA) {  
  94.             Log.e(TAG, "addNetwork() ## unknown type = " + type);  
  95.         }  
  96.           
  97.         stopTimer();  
  98.         unRegister();  
  99.           
  100.         addNetwork(createWifiInfo(ssid, passwd, type));  
  101.     }  
  102.   
  103.     private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {  
  104.   
  105.         @Override  
  106.         public void onReceive(Context context, Intent intent) {  
  107.             // TODO Auto-generated method stub  
  108.             if (intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) {  
  109.                 Log.d(TAG, "RSSI changed");  
  110.                   
  111.                 //有可能是正在获取，或者已经获取了  
  112.                 Log.d(TAG, " intent is " + WifiManager.RSSI_CHANGED_ACTION);  
  113.                   
  114.                 if (isWifiContected(mContext) == WIFI_CONNECTED) {  
  115.                     stopTimer();  
  116.                     onNotifyWifiConnected();  
  117.                     unRegister();  
  118.                 } else if (isWifiContected(mContext) == WIFI_CONNECT_FAILED) {  
  119.                     stopTimer();  
  120.                     closeWifi();  
  121.                     onNotifyWifiConnectFailed();  
  122.                     unRegister();  
  123.                 } else if (isWifiContected(mContext) == WIFI_CONNECTING) {  
  124.                       
  125.                 }  
  126.             }  
  127.         }  
  128.     };  
  129.       
  130.     private final int STATE_REGISTRING = 0x01;  
  131.     private final int STATE_REGISTERED = 0x02;  
  132.     private final int STATE_UNREGISTERING = 0x03;  
  133.     private final int STATE_UNREGISTERED = 0x04;  
  134.       
  135.     private int mHaveRegister = STATE_UNREGISTERED;  
  136.     private synchronized void register() {  
  137.         Log.v(TAG, "register() ##mHaveRegister = " + mHaveRegister);  
  138.   
  139.         if (mHaveRegister == STATE_REGISTRING   
  140.                 || mHaveRegister == STATE_REGISTERED) {  
  141.             return ;  
  142.         }  
  143.           
  144.         mHaveRegister = STATE_REGISTRING;  
  145.         myRegisterReceiver(mBroadcastReceiver, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION));  
  146.         mHaveRegister = STATE_REGISTERED;  
  147.           
  148.         startTimer();  
  149.     }  
  150.       
  151.     private synchronized void unRegister() {  
  152.         Log.v(TAG, "unRegister() ##mHaveRegister = " + mHaveRegister);  
  153.           
  154.         if (mHaveRegister == STATE_UNREGISTERED   
  155.                 || mHaveRegister == STATE_UNREGISTERING) {  
  156.             return ;  
  157.         }  
  158.           
  159.         mHaveRegister = STATE_UNREGISTERING;  
  160.         myUnregisterReceiver(mBroadcastReceiver);  
  161.         mHaveRegister = STATE_UNREGISTERED;  
  162.     }  
  163.       
  164.     private Timer mTimer = null;  
  165.     private void startTimer() {  
  166.         if (mTimer != null) {  
  167.             stopTimer();  
  168.         }  
  169.           
  170.         mTimer = new Timer(true);  
  171. //      mTimer.schedule(mTimerTask, 0, 20 * 1000);// 20s  
  172.         mTimer.schedule(mTimerTask, 30 * 1000);  
  173.     }  
  174.       
  175.     private TimerTask mTimerTask = new TimerTask() {  
  176.           
  177.         @Override  
  178.         public void run() {  
  179.             // TODO Auto-generated method stub  
  180.             Log.e(TAG, "timer out!");  
  181.             onNotifyWifiConnectFailed();  
  182.             unRegister();  
  183.         }  
  184.     };  
  185.       
  186.     private void stopTimer() {  
  187.         if (mTimer != null) {  
  188.             mTimer.cancel();  
  189.             mTimer = null;  
  190.         }  
  191.     }  
  192.       
  193.     @Override  
  194.     protected void finalize() {  
  195.         try {  
  196.             super.finalize();  
  197.             unRegister();  
  198.         } catch (Throwable e) {  
  199.             // TODO Auto-generated catch block  
  200.             e.printStackTrace();  
  201.         }  
  202.     }  
  203.       
  204.     public WifiConfiguration createWifiInfo(String SSID, String password, int type) {  
  205.           
  206.         Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);  
  207.           
  208.         WifiConfiguration config = new WifiConfiguration();  
  209.         config.allowedAuthAlgorithms.clear();  
  210.         config.allowedGroupCiphers.clear();  
  211.         config.allowedKeyManagement.clear();  
  212.         config.allowedPairwiseCiphers.clear();  
  213.         config.allowedProtocols.clear();  
  214.         config.SSID = "\"" + SSID + "\"";  
  215.   
  216.         WifiConfiguration tempConfig = this.IsExsits(SSID);  
  217.         if (tempConfig != null) {  
  218.             mWifiManager.removeNetwork(tempConfig.networkId);  
  219.         }  
  220.           
  221.         // 分为三种情况：1没有密码2用wep加密3用wpa加密  
  222.         if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS  
  223.             config.wepKeys[0] = "";  
  224.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
  225.             config.wepTxKeyIndex = 0;  
  226.               
  227.         } else if (type == TYPE_WEP) {  //  WIFICIPHER_WEP   
  228.             config.hiddenSSID = true;  
  229.             config.wepKeys[0] = "\"" + password + "\"";  
  230.             config.allowedAuthAlgorithms  
  231.                     .set(WifiConfiguration.AuthAlgorithm.SHARED);  
  232.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  233.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  234.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);  
  235.             config.allowedGroupCiphers  
  236.                     .set(WifiConfiguration.GroupCipher.WEP104);  
  237.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);  
  238.             config.wepTxKeyIndex = 0;  
  239.         } else if (type == TYPE_WPA) {   // WIFICIPHER_WPA  
  240.             config.preSharedKey = "\"" + password + "\"";  
  241.             config.hiddenSSID = true;  
  242.             config.allowedAuthAlgorithms  
  243.                     .set(WifiConfiguration.AuthAlgorithm.OPEN);  
  244.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);  
  245.             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);  
  246.             config.allowedPairwiseCiphers  
  247.                     .set(WifiConfiguration.PairwiseCipher.TKIP);  
  248.             // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
  249.             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);  
  250.             config.allowedPairwiseCiphers  
  251.                     .set(WifiConfiguration.PairwiseCipher.CCMP);  
  252.             config.status = WifiConfiguration.Status.ENABLED;  
  253.         }   
  254.           
  255.         return config;  
  256.     }  
  257.       
  258.     public static final int WIFI_CONNECTED = 0x01;  
  259.     public static final int WIFI_CONNECT_FAILED = 0x02;  
  260.     public static final int WIFI_CONNECTING = 0x03;  
  261.     /** 
  262.      * 判断wifi是否连接成功,不是network 
  263.      *  
  264.      * @param context 
  265.      * @return 
  266.      */  
  267.     public int isWifiContected(Context context) {  
  268.         ConnectivityManager connectivityManager = (ConnectivityManager) context  
  269.                 .getSystemService(Context.CONNECTIVITY_SERVICE);  
  270.         NetworkInfo wifiNetworkInfo = connectivityManager  
  271.                 .getNetworkInfo(ConnectivityManager.TYPE_WIFI);  
  272.           
  273.         Log.v(TAG, "isConnectedOrConnecting = " + wifiNetworkInfo.isConnectedOrConnecting());  
  274.         Log.d(TAG, "wifiNetworkInfo.getDetailedState() = " + wifiNetworkInfo.getDetailedState());  
  275.         if (wifiNetworkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR  
  276.                 || wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTING) {  
  277.             return WIFI_CONNECTING;  
  278.         } else if (wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTED) {  
  279.             return WIFI_CONNECTED;  
  280.         } else {  
  281.             Log.d(TAG, "getDetailedState() == " + wifiNetworkInfo.getDetailedState());  
  282.             return WIFI_CONNECT_FAILED;  
  283.         }  
  284.     }  
  285.       
  286.     private WifiConfiguration IsExsits(String SSID) {  
  287.         List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();  
  288.         for (WifiConfiguration existingConfig : existingConfigs) {  
  289.             if (existingConfig.SSID.equals("\"" + SSID + "\"") /*&& existingConfig.preSharedKey.equals("\"" + password + "\"")*/) {  
  290.                 return existingConfig;  
  291.             }  
  292.         }  
  293.         return null;  
  294.     }  
  295.       
  296.   
  297.   
  298.     // 断开指定ID的网络  
  299.     public void disconnectWifi(int netId) {  
  300.         mWifiManager.disableNetwork(netId);  
  301.         mWifiManager.disconnect();  
  302.     }  
  303.       
  304.     // 检查当前WIFI状态  
  305.     public int checkState() {  
  306.         return mWifiManager.getWifiState();  
  307.     }  
  308.   
  309.     // 锁定WifiLock  
  310.     public void acquireWifiLock() {  
  311.         mWifiLock.acquire();  
  312.     }  
  313.   
  314.     // 解锁WifiLock  
  315.     public void releaseWifiLock() {  
  316.         // 判断时候锁定  
  317.         if (mWifiLock.isHeld()) {  
  318.             mWifiLock.acquire();  
  319.         }  
  320.     }  
  321.   
  322.     // 创建一个WifiLock  
  323.     public void creatWifiLock() {  
  324.         mWifiLock = mWifiManager.createWifiLock("Test");  
  325.     }  
  326.   
  327.     // 得到配置好的网络  
  328.     public List<WifiConfiguration> getConfiguration() {  
  329.         return mWifiConfiguration;  
  330.     }  
  331.   
  332.     // 指定配置好的网络进行连接  
  333.     public void connectConfiguration(int index) {  
  334.         // 索引大于配置好的网络索引返回  
  335.         if (index > mWifiConfiguration.size()) {  
  336.             return;  
  337.         }  
  338.         // 连接配置好的指定ID的网络  
  339.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,  
  340.                 true);  
  341.     }  
  342.   
  343.     public void startScan() {  
  344.         mWifiManager.startScan();  
  345.         mWifiList = mWifiManager.getScanResults();  
  346.         mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
  347.     }  
  348.   
  349.     // 得到网络列表  
  350.     public List<ScanResult> getWifiList() {  
  351.         return mWifiList;  
  352.     }  
  353.   
  354.     // 查看扫描结果  
  355.     public StringBuilder lookUpScan() {  
  356.         StringBuilder stringBuilder = new StringBuilder();  
  357.         for (int i = 0; i < mWifiList.size(); i++) {  
  358.             stringBuilder  
  359.                     .append("Index_" + new Integer(i + 1).toString() + ":");  
  360.             // 将ScanResult信息转换成一个字符串包  
  361.             // 其中把包括：BSSID、SSID、capabilities、frequency、level  
  362.             stringBuilder.append((mWifiList.get(i)).toString());  
  363.             stringBuilder.append("/n");  
  364.         }  
  365.         return stringBuilder;  
  366.     }  
  367.   
  368.     // 得到MAC地址  
  369.     public String getMacAddress() {  
  370.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
  371.     }  
  372.   
  373.     // 得到接入点的BSSID  
  374.     public String getBSSID() {  
  375.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
  376.     }  
  377.   
  378.     // 得到IP地址  
  379.     public int getIPAddress() {  
  380.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
  381.     }  
  382.   
  383.     // 得到连接的ID  
  384.     public int getNetworkId() {  
  385.         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
  386.     }  
  387.   
  388.     // 得到WifiInfo的所有信息包  
  389.     public String getWifiInfo() {  
  390.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
  391.     }  
  392. }  

WifiApAdmin.java

参考了 http://blog.csdn.net/cxlmax/article/details/7827102

[java] view
plaincopy

  1. package com.widget.hotspot;  
  2.   
  3. import java.lang.reflect.InvocationTargetException;  
  4. import java.lang.reflect.Method;  
  5. import java.util.Timer;  
  6. import java.util.TimerTask;  
  7.   
  8. import android.content.Context;  
  9. import android.net.wifi.WifiConfiguration;  
  10. import android.net.wifi.WifiManager;  
  11. import android.util.Log;  
  12.   
  13. /** 
  14.  * 创建热点 
  15.  * 
  16.  */  
  17. public class WifiApAdmin {  
  18.     public static final String TAG = "WifiApAdmin";  
  19.       
  20.     public static void closeWifiAp(Context context) {  
  21.         WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);   
  22.         closeWifiAp(wifiManager);  
  23.     }  
  24.       
  25.     private WifiManager mWifiManager = null;  
  26.       
  27.     private Context mContext = null;  
  28.     public WifiApAdmin(Context context) {  
  29.         mContext = context;  
  30.           
  31.         mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);    
  32.           
  33.         closeWifiAp(mWifiManager);  
  34.     }  
  35.       
  36.     private String mSSID = "";  
  37.     private String mPasswd = "";  
  38.     public void startWifiAp(String ssid, String passwd) {  
  39.         mSSID = ssid;  
  40.         mPasswd = passwd;  
  41.           
  42.         if (mWifiManager.isWifiEnabled()) {  
  43.             mWifiManager.setWifiEnabled(false);  
  44.         }   
  45.           
  46.         stratWifiAp();  
  47.           
  48.         MyTimerCheck timerCheck = new MyTimerCheck() {  
  49.               
  50.             @Override  
  51.             public void doTimerCheckWork() {  
  52.                 // TODO Auto-generated method stub  
  53.                   
  54.                 if (isWifiApEnabled(mWifiManager)) {  
  55.                     Log.v(TAG, "Wifi enabled success!");  
  56.                     this.exit();  
  57.                 } else {  
  58.                     Log.v(TAG, "Wifi enabled failed!");  
  59.                 }  
  60.             }  
  61.   
  62.             @Override  
  63.             public void doTimeOutWork() {  
  64.                 // TODO Auto-generated method stub  
  65.                 this.exit();  
  66.             }  
  67.         };  
  68.         timerCheck.start(15, 1000);  
  69.           
  70.     }  
  71.   
  72.     public void stratWifiAp() {  
  73.         Method method1 = null;  
  74.         try {  
  75.             method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",  
  76.                     WifiConfiguration.class, boolean.class);  
  77.             WifiConfiguration netConfig = new WifiConfiguration();  
  78.   
  79.             netConfig.SSID = mSSID;  
  80.             netConfig.preSharedKey = mPasswd;  
  81.   
  82.             netConfig.allowedAuthAlgorithms  
  83.                     .set(WifiConfiguration.AuthAlgorithm.OPEN);  
  84.             netConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);  
  85.             netConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);  
  86.             netConfig.allowedKeyManagement  
  87.                     .set(WifiConfiguration.KeyMgmt.WPA_PSK);  
  88.             netConfig.allowedPairwiseCiphers  
  89.                     .set(WifiConfiguration.PairwiseCipher.CCMP);  
  90.             netConfig.allowedPairwiseCiphers  
  91.                     .set(WifiConfiguration.PairwiseCipher.TKIP);  
  92.             netConfig.allowedGroupCiphers  
  93.                     .set(WifiConfiguration.GroupCipher.CCMP);  
  94.             netConfig.allowedGroupCiphers  
  95.                     .set(WifiConfiguration.GroupCipher.TKIP);  
  96.   
  97.             method1.invoke(mWifiManager, netConfig, true);  
  98.   
  99.         } catch (IllegalArgumentException e) {  
  100.             // TODO Auto-generated catch block  
  101.             e.printStackTrace();  
  102.         } catch (IllegalAccessException e) {  
  103.             // TODO Auto-generated catch block  
  104.             e.printStackTrace();  
  105.         } catch (InvocationTargetException e) {  
  106.             // TODO Auto-generated catch block  
  107.             e.printStackTrace();  
  108.         } catch (SecurityException e) {  
  109.             // TODO Auto-generated catch block  
  110.             e.printStackTrace();  
  111.         } catch (NoSuchMethodException e) {  
  112.             // TODO Auto-generated catch block  
  113.             e.printStackTrace();  
  114.         }  
  115.     }  
  116.   
  117.     private static void closeWifiAp(WifiManager wifiManager) {  
  118.         if (isWifiApEnabled(wifiManager)) {  
  119.             try {  
  120.                 Method method = wifiManager.getClass().getMethod("getWifiApConfiguration");  
  121.                 method.setAccessible(true);  
  122.   
  123.                 WifiConfiguration config = (WifiConfiguration) method.invoke(wifiManager);  
  124.   
  125.                 Method method2 = wifiManager.getClass().getMethod("setWifiApEnabled", WifiConfiguration.class, boolean.class);  
  126.                 method2.invoke(wifiManager, config, false);  
  127.             } catch (NoSuchMethodException e) {  
  128.                 // TODO Auto-generated catch block  
  129.                 e.printStackTrace();  
  130.             } catch (IllegalArgumentException e) {  
  131.                 // TODO Auto-generated catch block  
  132.                 e.printStackTrace();  
  133.             } catch (IllegalAccessException e) {  
  134.                 // TODO Auto-generated catch block  
  135.                 e.printStackTrace();  
  136.             } catch (InvocationTargetException e) {  
  137.                 // TODO Auto-generated catch block  
  138.                 e.printStackTrace();  
  139.             }  
  140.         }  
  141.     }  
  142.   
  143.     private static boolean isWifiApEnabled(WifiManager wifiManager) {  
  144.         try {  
  145.             Method method = wifiManager.getClass().getMethod("isWifiApEnabled");  
  146.             method.setAccessible(true);  
  147.             return (Boolean) method.invoke(wifiManager);  
  148.   
  149.         } catch (NoSuchMethodException e) {  
  150.             // TODO Auto-generated catch block  
  151.             e.printStackTrace();  
  152.         } catch (Exception e) {  
  153.             e.printStackTrace();  
  154.         }  
  155.   
  156.         return false;  
  157.     }  
  158.   
  159. }  

MyTimeCheck.java

[java] view
plaincopy

  1. package com.widget.hotspot;  
  2.   
  3.   
  4. public abstract class MyTimerCheck {  
  5.     private int mCount = 0;  
  6.     private int mTimeOutCount = 1;  
  7.     private int mSleepTime = 1000; // 1s  
  8.     private boolean mExitFlag = false;  
  9.     private Thread mThread = null;  
  10.       
  11.     /** 
  12.      * Do not process UI work in this. 
  13.      */  
  14.     public abstract void doTimerCheckWork();  
  15.       
  16.     public abstract void doTimeOutWork();  
  17.       
  18.     public MyTimerCheck() {  
  19.         mThread = new Thread(new Runnable() {  
  20.               
  21.             @Override  
  22.             public void run() {  
  23.                 // TODO Auto-generated method stub  
  24.                 while (!mExitFlag) {  
  25.                     mCount++;  
  26.                     if (mCount < mTimeOutCount) {  
  27.                         doTimerCheckWork();  
  28.                         try {  
  29.                             mThread.sleep(mSleepTime);  
  30.                         } catch (InterruptedException e) {  
  31.                             // TODO Auto-generated catch block  
  32.                             e.printStackTrace();  
  33.                             exit();  
  34.                         }  
  35.                     } else {  
  36.                         doTimeOutWork();  
  37.                     }  
  38.                 }  
  39.             }  
  40.         });  
  41.     }  
  42.       
  43.     /** 
  44.      * start 
  45.      * @param times  How many times will check? 
  46.      * @param sleepTime ms, Every check sleep time. 
  47.      */  
  48.     public void start(int timeOutCount, int sleepTime) {  
  49.         mTimeOutCount = timeOutCount;  
  50.         mSleepTime = sleepTime;  
  51.           
  52.         mThread.start();  
  53.     }  
  54.       
  55.     public void exit() {  
  56.         mExitFlag = true;  
  57.     }  
  58.       
  59. }  

xml布局简单不上了，

效果自己试试看打印就知道了

//分为三种情况：1没有密码2用wep加密3用wpa加密 

改动主要集中在CreateWifiInfo这个方法中，并且添加了一个私有方法：

（1）将与方法的第三个参数有关的变量都改成int型，或者使用原作者的枚举型（存在bug需要改正），但枚举会在后续的开发中遇到些困难；

（2）在if(type == 3)中注释掉“config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);”，并添加“

config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP); config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);“这两句，否则当wifi热点需要输入密码时，无法加入网络。

（3）在代码末尾添加了方法IsExsits，原因在于如果按照网上介绍的方法成功加入指定的wifi后，都会在终端的wifi列表中新添加一个以该指定ssid的网络，所以每运行一次程序，列表中就会多一个相同名字的ssid。而该方法就是检查wifi列表中是否有以输入参数为名的wifi热点，如果存在，则在CreateWifiInfo方法开始配置wifi网络之前将其移除，以避免ssid的重复：

WifiConfiguration tempConfig = this.IsExsits(SSID);          

          if(tempConfig != null) { 

          mWifiManager.removeNetwork(tempConfig.networkId); 

          }

以上便是wifi工具类的建立，之后就可以在其他部分实例化这个类，调用其中的方法完成加入指定ssid的wifi热点，还是先上代码吧，建立一个名为Test_wifiActivity.java的文件（同上，没有包含包声明和import语句）：

[java] 
public class Test_wifiActivity extends Activity { 
    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.main); 
         
        WifiAdmin wifiAdmin = new WifiAdmin(this); 
        wifiAdmin.openWifi(); 
        wifiAdmin.addNetwork(wifiAdmin.CreateWifiInfo("XXX", "XXX", 3)); 
    } 
} 

很简单，如果是接入wifi，大体上只涉及到openWifi(打开wifi)、CreateWifiInfo(配置wifi网络信息)和addNetwork（添加配置好的网络并连接），对CreateWifiInfo进行简单的说明：第一参数是SSID的名称；第二个参数是指定SSID网络的密码，当不需要密码是置空（”“）；第三个参数是热点类型：1-无密码 / 2-WEP密码验证（未测试）/ 3-WAP或WAP2 PSK密码验证。

连接不加密热点总是失败 addNetwork总是返回-1的解决办法：

  if(Type == WifiCipherType.WIFICIPHER_NOPASS)      {      config.hiddenSSID = true;  //        config.wepKeys[0] = "";        config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);//        config.wepTxKeyIndex = 0;      }

把与wep有关的都注释掉就行了

时间： 2024-11-03 15:06:31

Android 连接Wifi和创建Wifi热点 demo的相关文章

Android开发——自动连接指定SSID的wifi热点（不加密/加密）

最近在做一个项目,其中涉及到一块"自动连接已存在的wifi热点"的功能,在网上查阅了大量资料,五花八门,但其中一些说的很简单,即不能实现傻瓜式的拿来就用,有些说的很详细,但其中不乏些许错误造成功能无法实现,经过浣熊多方努力,终于成功将功能实现,遂将一点点小成就拿出来与大家分享. 首先需要感谢这篇文章的作者:http://blog.chinaunix.net/uid-22342564-id-3228565.html 在这篇文章中,作者定义了一个wifi工具类,其中存在着操作wifi的各种

wifi热点-Android 如何获取所有的wifi连接历史记录？

问题描述 Android 如何获取所有的wifi连接历史记录? 不是附近的wifi热点,而是本机所有连接过的wifi热点名称.也就是保存过的wifi热点信息. 解决方案 1.首先安卓系统必须root才可以获取这样的文件信息. 2.root之后使用Re管理器这样的软件. 3.路径:?/data/misc/wifi 4.文件名称:wpa_supplicant.conf 用文本模式查看 在这里就有你要查看的连接WiFi密码名称

Android开发之扫描附近wifi热点并列表显示

 最近项目中用到了wifi模块,今天做一个简单的总结. 参考:http://www.2cto.com/kf/201310/253617.html 1.怎样获取wifi对象并进行操作 要操作WIFI设备,需要先获取Context.getSystemService(Context.WIFI_SERVICE)来获取WifiManager对象,并通过这个对象来管理WIFI设备.   addNetwork(WifiConfiguration config) 添加一个config描述的WIFI网络,默认情况

Android连接指定Wifi的方法实例代码

本篇文章主要记录一下Android中打开Wifi.获取Wifi接入点信息及连接指接入点的方法. 自己写的demo主要用于测试接口的基本功能,因此界面及底层逻辑比较粗糙. demo的整体界面如下所示: 上图中的OPEN按键负责开启Wifi: GET按键负责获取扫描到的接入点信息. 当获取到接入点信息后,我选取了其中的名称及信号强度,以列表的形式显示在主界面下方,如下图: 当点击列表中的Item时,就会去连接对应的接入点. 自己的逻辑比较简单,测试时的代码,假定连接的是不许要密码或密码已知的接入点.

ubuntu创建wifi热点(手机可识别)

这几天实验室的无线网跪了,一直纠结着用电脑开无线的问题,试了几种办法都不能解决这个问题,不过最终还是找到了一个终极方法,给大家分享一下. 一开始我是用Ubuntu自带的network manager进行设置的,其他的笔记本电脑或者windows平板可以发现此无线网络.但是我的Android手机却不行,貌似Android系统不支持Ad-hoc. 不管怎么样还是给大家分享一下这种方法,至少方便的给别的电脑分享无线网络. 一 使用系统自带的network manager(安卓不可用) 第一步: 单机屏

mac创建wifi热点方法：苹果mac设置无线网络wifi共享步骤

  -"暗恋一个人什么感觉?"--"总感觉他身上有WiFi."所以为了让更多的人暗恋你,一定要学会创建WiFi热点这一技能,今天传授给大家的就是mac创建wifi热点的方法,机友们可以来看一看. 首先,连接网线,进入设置,选择"共享". 在互联网共享这一栏选择要共享的网络,以太网或者PPPoE链接. 之后在下面选择通过Wi-Fi共享. 点击Wi-Fi选项设定共享密码. 都完成后在左边互联网共享前面的选择框内打钩,启用共享. 之后就可以使用移动设备

Win8下如何创建WiFi热点共享

很多时候,你都会想利用你的笔记本的无线网卡为其他的笔记本.手机等设备提供无线网络,Win8下如何创建WiFi热点共享呢? 操作步骤: 设置如下: 1. 在桌面左下角右击,选择命令指令符(管理员); 2. 启用并设定虚拟WiFi网卡; 运行命令: netsh wlan set hostednetwork mode=allow ssid=cai key=12345678 此命令有三个参数, mode:是否启用虚拟WiFi网卡,改为disallow则为禁用. ssid:无线网名称,最好用英文(以cai

Win10笔记本电脑怎么创建Wifi热点？

  如今,Win10创建Wifi热点非常简单,可以使用的工具非常多,只需要在Win10笔记本中安装使用Wifi共享精灵.360安全卫士.金山卫士.鲁大师.116Wifi等软件,就可以轻松的在笔记本创建Wifi热点,让附近的智能手机/平板电脑等无线上网设备免费Wifi上网.以下是笔记本安装Wifi共享精灵设置Wifi热点方法. Win10笔记本设置WiFi热点方法 一.首先Win10笔记本中下载Wifi共享精灵,在安装的时候,建议选择"自定义"安装,然后将[安装电脑QQ管家]前面的勾去掉

信号-VC++如何实现电脑创建wifi热点？

问题描述 VC++如何实现电脑创建wifi热点? 希望能给个实例代码,实现如下功能: 1.建立的wifi热点有开放和加密两种模式 2.能扫描周围的wifi信号 解决方案 电脑带有无线WIFI网卡,这样可以作为AP,提供WIFI信号给其他访问 解决方案二: 1.以管理员身份运行命令提示符: 快捷键win+R→输入cmd→然后win7会自动搜索出cmd命令,右键点击-以管理员身份运行 2.启用并设定虚拟WiFi网卡: 运行命令:netsh wlan set hostednetwork mode=al