Android 连接Wifi和创建Wifi热点 demo

[java] view plaincopy

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

[java] view plaincopy

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

上代码：

MainActivity.java

[java] view plaincopy

package com.widget.hotspot;

import android.os.Bundle;

import android.app.Activity;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.util.Log;

import android.view.Menu;

import android.view.View;

import android.widget.Button;

public class MainActivity extends Activity {

public static final String TAG = "MainActivity";

private Button mBtn1, mBtn2;

private WifiAdmin mWifiAdmin;

private Context mContext = null;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

mContext = this;

setContentView(R.layout.activity_main);

mBtn1 = (Button)findViewById(R.id.button1);

mBtn2 = (Button)findViewById(R.id.button2);

mBtn1.setText("点击连接Wifi");

mBtn2.setText("点击创建Wifi热点");

mBtn1.setOnClickListener(new Button.OnClickListener() {

@Override

public void onClick(View v) {

// TODO Auto-generated method stub

mWifiAdmin = new WifiAdmin(mContext) {

@Override

public void myUnregisterReceiver(BroadcastReceiver receiver) {

// TODO Auto-generated method stub

MainActivity.this.unregisterReceiver(receiver);

}

@Override

public Intent myRegisterReceiver(BroadcastReceiver receiver,

IntentFilter filter) {

// TODO Auto-generated method stub

MainActivity.this.registerReceiver(receiver, filter);

return null;

}

@Override

public void onNotifyWifiConnected() {

// TODO Auto-generated method stub

Log.v(TAG, "have connected success!");

Log.v(TAG, "###############################");

}

@Override

public void onNotifyWifiConnectFailed() {

// TODO Auto-generated method stub

Log.v(TAG, "have connected failed!");

Log.v(TAG, "###############################");

}

};

mWifiAdmin.openWifi();

mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI", "MM123456", WifiAdmin.TYPE_WPA));

}

});

mBtn2.setOnClickListener(new Button.OnClickListener() {

@Override

public void onClick(View v) {

// TODO Auto-generated method stub

WifiApAdmin wifiAp = new WifiApAdmin(mContext);

wifiAp.startWifiAp("\"HotSpot\"", "hhhhhh123");

}

});

}

@Override

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the action bar if it is present.

getMenuInflater().inflate(R.menu.activity_main, menu);

return true;

}

@Override

public void onResume() {

super.onResume();

Log.d("Rssi", "Registered");

}

@Override

public void onPause() {

super.onPause();

Log.d("Rssi", "Unregistered");

}

}

WifiAdmin.java

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

[java] view plaincopy

package com.widget.hotspot;

import java.util.List;

import java.util.Timer;

import java.util.TimerTask;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.net.ConnectivityManager;

import android.net.NetworkInfo;

import android.net.NetworkInfo.DetailedState;

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;

public abstract class WifiAdmin {

private static final String TAG = "WifiAdmin";

private WifiManager mWifiManager;

private WifiInfo mWifiInfo;

// 扫描出的网络连接列表

private List<ScanResult> mWifiList;

private List<WifiConfiguration> mWifiConfiguration;

private WifiLock mWifiLock;

private String mPasswd = "";

private String mSSID = "";

private Context mContext = null;

public WifiAdmin(Context context) {

mContext = context;

// 取得WifiManager对象

mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

// 取得WifiInfo对象

mWifiInfo = mWifiManager.getConnectionInfo();

Log.v(TAG, "getIpAddress = " + mWifiInfo.getIpAddress());

}

// 打开WIFI

public void openWifi() {

if (!mWifiManager.isWifiEnabled()) {

mWifiManager.setWifiEnabled(true);

}

}

// 关闭WIFI

public void closeWifi() {

if (mWifiManager.isWifiEnabled()) {

mWifiManager.setWifiEnabled(false);

}

}

public abstract Intent myRegisterReceiver(BroadcastReceiver receiver, IntentFilter filter);

public abstract void myUnregisterReceiver(BroadcastReceiver receiver);

public abstract void onNotifyWifiConnected();

public abstract void onNotifyWifiConnectFailed();

// 添加一个网络并连接

public void addNetwork(WifiConfiguration wcg) {

register();

WifiApAdmin.closeWifiAp(mContext);

int wcgID = mWifiManager.addNetwork(wcg);

boolean b = mWifiManager.enableNetwork(wcgID, true);

}

public static final int TYPE_NO_PASSWD = 0x11;

public static final int TYPE_WEP = 0x12;

public static final int TYPE_WPA = 0x13;

public void addNetwork(String ssid, String passwd, int type) {

if (ssid == null || passwd == null || ssid.equals("")) {

Log.e(TAG, "addNetwork() ## nullpointer error!");

return;

}

if (type != TYPE_NO_PASSWD && type != TYPE_WEP && type != TYPE_WPA) {

Log.e(TAG, "addNetwork() ## unknown type = " + type);

}

stopTimer();

unRegister();

addNetwork(createWifiInfo(ssid, passwd, type));

}

private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {

@Override

public void onReceive(Context context, Intent intent) {

// TODO Auto-generated method stub

if (intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)) {

Log.d(TAG, "RSSI changed");

//有可能是正在获取，或者已经获取了

Log.d(TAG, " intent is " + WifiManager.RSSI_CHANGED_ACTION);

if (isWifiContected(mContext) == WIFI_CONNECTED) {

stopTimer();

onNotifyWifiConnected();

unRegister();

} else if (isWifiContected(mContext) == WIFI_CONNECT_FAILED) {

stopTimer();

closeWifi();

onNotifyWifiConnectFailed();

unRegister();

} else if (isWifiContected(mContext) == WIFI_CONNECTING) {

}

}

}

};

private final int STATE_REGISTRING = 0x01;

private final int STATE_REGISTERED = 0x02;

private final int STATE_UNREGISTERING = 0x03;

private final int STATE_UNREGISTERED = 0x04;

private int mHaveRegister = STATE_UNREGISTERED;

private synchronized void register() {

Log.v(TAG, "register() ##mHaveRegister = " + mHaveRegister);

if (mHaveRegister == STATE_REGISTRING

|| mHaveRegister == STATE_REGISTERED) {

return ;

}

mHaveRegister = STATE_REGISTRING;

myRegisterReceiver(mBroadcastReceiver, new IntentFilter(WifiManager.RSSI_CHANGED_ACTION));

mHaveRegister = STATE_REGISTERED;

startTimer();

}

private synchronized void unRegister() {

Log.v(TAG, "unRegister() ##mHaveRegister = " + mHaveRegister);

if (mHaveRegister == STATE_UNREGISTERED

|| mHaveRegister == STATE_UNREGISTERING) {

return ;

}

mHaveRegister = STATE_UNREGISTERING;

myUnregisterReceiver(mBroadcastReceiver);

mHaveRegister = STATE_UNREGISTERED;

}

private Timer mTimer = null;

private void startTimer() {

if (mTimer != null) {

stopTimer();

}

mTimer = new Timer(true);

// mTimer.schedule(mTimerTask, 0, 20 * 1000);// 20s

mTimer.schedule(mTimerTask, 30 * 1000);

}

private TimerTask mTimerTask = new TimerTask() {

@Override

public void run() {

// TODO Auto-generated method stub

Log.e(TAG, "timer out!");

onNotifyWifiConnectFailed();

unRegister();

}

};

private void stopTimer() {

if (mTimer != null) {

mTimer.cancel();

mTimer = null;

}

}

@Override

protected void finalize() {

try {

super.finalize();

unRegister();

} catch (Throwable e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public WifiConfiguration createWifiInfo(String SSID, String password, int type) {

Log.v(TAG, "SSID = " + SSID + "## Password = " + password + "## Type = " + type);

WifiConfiguration config = new WifiConfiguration();

config.allowedAuthAlgorithms.clear();

config.allowedGroupCiphers.clear();

config.allowedKeyManagement.clear();

config.allowedPairwiseCiphers.clear();

config.allowedProtocols.clear();

config.SSID = "\"" + SSID + "\"";

WifiConfiguration tempConfig = this.IsExsits(SSID);

if (tempConfig != null) {

mWifiManager.removeNetwork(tempConfig.networkId);

}

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

if (type == TYPE_NO_PASSWD) {// WIFICIPHER_NOPASS

config.wepKeys[0] = "";

config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);

config.wepTxKeyIndex = 0;

} else if (type == TYPE_WEP) { // WIFICIPHER_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;

} else if (type == TYPE_WPA) { // 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;

}

return config;

}

public static final int WIFI_CONNECTED = 0x01;

public static final int WIFI_CONNECT_FAILED = 0x02;

public static final int WIFI_CONNECTING = 0x03;

/**

* 判断wifi是否连接成功,不是network

*

* @param context

* @return

*/

public int isWifiContected(Context context) {

ConnectivityManager connectivityManager = (ConnectivityManager) context

.getSystemService(Context.CONNECTIVITY_SERVICE);

NetworkInfo wifiNetworkInfo = connectivityManager

.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

Log.v(TAG, "isConnectedOrConnecting = " + wifiNetworkInfo.isConnectedOrConnecting());

Log.d(TAG, "wifiNetworkInfo.getDetailedState() = " + wifiNetworkInfo.getDetailedState());

if (wifiNetworkInfo.getDetailedState() == DetailedState.OBTAINING_IPADDR

|| wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTING) {

return WIFI_CONNECTING;

} else if (wifiNetworkInfo.getDetailedState() == DetailedState.CONNECTED) {

return WIFI_CONNECTED;

} else {

Log.d(TAG, "getDetailedState() == " + wifiNetworkInfo.getDetailedState());

return WIFI_CONNECT_FAILED;

}

}

private WifiConfiguration IsExsits(String SSID) {

List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();

for (WifiConfiguration existingConfig : existingConfigs) {

if (existingConfig.SSID.equals("\"" + SSID + "\"") /*&& existingConfig.preSharedKey.equals("\"" + password + "\"")*/) {

return existingConfig;

}

}

return null;

}

// 断开指定ID的网络

public void disconnectWifi(int netId) {

mWifiManager.disableNetwork(netId);

mWifiManager.disconnect();

}

// 检查当前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 creatWifiLock() {

mWifiLock = mWifiManager.createWifiLock("Test");

}

// 得到配置好的网络

public List<WifiConfiguration> getConfiguration() {

return mWifiConfiguration;

}

// 指定配置好的网络进行连接

public void connectConfiguration(int index) {

// 索引大于配置好的网络索引返回

if (index > mWifiConfiguration.size()) {

return;

}

// 连接配置好的指定ID的网络

mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,

true);

}

public void startScan() {

mWifiManager.startScan();

mWifiList = mWifiManager.getScanResults();

mWifiConfiguration = mWifiManager.getConfiguredNetworks();

}

// 得到网络列表

public List<ScanResult> getWifiList() {

return mWifiList;

}

// 查看扫描结果

public StringBuilder lookUpScan() {

StringBuilder stringBuilder = new StringBuilder();

for (int i = 0; i < mWifiList.size(); i++) {

stringBuilder

.append("Index_" + new Integer(i + 1).toString() + ":");

// 将ScanResult信息转换成一个字符串包

// 其中把包括：BSSID、SSID、capabilities、frequency、level

stringBuilder.append((mWifiList.get(i)).toString());

stringBuilder.append("/n");

}

return stringBuilder;

}

// 得到MAC地址

public String getMacAddress() {

return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();

}

// 得到接入点的BSSID

public String getBSSID() {

return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();

}

// 得到IP地址

public int getIPAddress() {

return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();

}

// 得到连接的ID

public int getNetworkId() {

return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();

}

// 得到WifiInfo的所有信息包

public String getWifiInfo() {

return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();

}

}

WifiApAdmin.java

参考了 http://blog.csdn.net/cxlmax/article/details/7827102
[java] view plaincopy

package com.widget.hotspot;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Timer;

import java.util.TimerTask;

import android.content.Context;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiManager;

import android.util.Log;

/**

* 创建热点

*

*/

public class WifiApAdmin {

public static final String TAG = "WifiApAdmin";

public static void closeWifiAp(Context context) {

WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

closeWifiAp(wifiManager);

}

private WifiManager mWifiManager = null;

private Context mContext = null;

public WifiApAdmin(Context context) {

mContext = context;

mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);

closeWifiAp(mWifiManager);

}

private String mSSID = "";

private String mPasswd = "";

public void startWifiAp(String ssid, String passwd) {

mSSID = ssid;

mPasswd = passwd;

if (mWifiManager.isWifiEnabled()) {

mWifiManager.setWifiEnabled(false);

}

stratWifiAp();

MyTimerCheck timerCheck = new MyTimerCheck() {

@Override

public void doTimerCheckWork() {

// TODO Auto-generated method stub

if (isWifiApEnabled(mWifiManager)) {

Log.v(TAG, "Wifi enabled success!");

this.exit();

} else {

Log.v(TAG, "Wifi enabled failed!");

}

}

@Override

public void doTimeOutWork() {

// TODO Auto-generated method stub

this.exit();

}

};

timerCheck.start(15, 1000);

}

public void stratWifiAp() {

Method method1 = null;

try {

method1 = mWifiManager.getClass().getMethod("setWifiApEnabled",

WifiConfiguration.class, boolean.class);

WifiConfiguration netConfig = new WifiConfiguration();

netConfig.SSID = mSSID;

netConfig.preSharedKey = mPasswd;

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);

method1.invoke(mWifiManager, netConfig, true);

} 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();

} catch (SecurityException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchMethodException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

private static 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();

}

}

}

private static 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;

}

}

MyTimeCheck.java

[java] view plaincopy

package com.widget.hotspot;

public abstract class MyTimerCheck {

private int mCount = 0;

private int mTimeOutCount = 1;

private int mSleepTime = 1000; // 1s

private boolean mExitFlag = false;

private Thread mThread = null;

/**

* Do not process UI work in this.

*/

public abstract void doTimerCheckWork();

public abstract void doTimeOutWork();

public MyTimerCheck() {

mThread = new Thread(new Runnable() {

@Override

public void run() {

// TODO Auto-generated method stub

while (!mExitFlag) {

mCount++;

if (mCount < mTimeOutCount) {

doTimerCheckWork();

try {

mThread.sleep(mSleepTime);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

exit();

}

} else {

doTimeOutWork();

}

}

}

});

}

/**

* start

* @param times How many times will check?

* @param sleepTime ms, Every check sleep time.

*/

public void start(int timeOutCount, int sleepTime) {

mTimeOutCount = timeOutCount;

mSleepTime = sleepTime;

mThread.start();

}

public void exit() {

mExitFlag = true;

}

}

xml布局简单不上了，

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