Android 连接Wifi和创建Wifi热点的实例
本文实例讲述了连接Wifi和创建Wifi热点的方法。分享给大家供大家参考，具体如下：
android的热点功能不可见，用了反射的技术搞定之外。
Eclipse设置语言为utf-8才能查看中文注释
上代码：
MainActivity.java
packagecom.widget.hotspot;
importandroid.os.Bundle;
importandroid.app.Activity;
importandroid.content.BroadcastReceiver;
importandroid.content.Context;
importandroid.content.Intent;
importandroid.content.IntentFilter;
importandroid.util.Log;
importandroid.view.Menu;
importandroid.view.View;
importandroid.widget.Button;
publicclassMainActivityextendsActivity{
publicstaticfinalStringTAG="MainActivity";
privateButtonmBtn1,mBtn2;
privateWifiAdminmWifiAdmin;
privateContextmContext=null;
@Override
protectedvoidonCreate(BundlesavedInstanceState){
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(newButton.OnClickListener(){
@Override
publicvoidonClick(Viewv){
//TODOAuto-generatedmethodstub
mWifiAdmin=newWifiAdmin(mContext){
@Override
publicvoidmyUnregisterReceiver(BroadcastReceiverreceiver){
//TODOAuto-generatedmethodstub
MainActivity.this.unregisterReceiver(receiver);
}
@Override
publicIntentmyRegisterReceiver(BroadcastReceiverreceiver,
IntentFilterfilter){
//TODOAuto-generatedmethodstub
MainActivity.this.registerReceiver(receiver,filter);
returnnull;
}
@Override
publicvoidonNotifyWifiConnected(){
//TODOAuto-generatedmethodstub
Log.v(TAG,"haveconnectedsuccess!");
Log.v(TAG,"###############################");
}
@Override
publicvoidonNotifyWifiConnectFailed(){
//TODOAuto-generatedmethodstub
Log.v(TAG,"haveconnectedfailed!");
Log.v(TAG,"###############################");
}
};
mWifiAdmin.openWifi();
mWifiAdmin.addNetwork(mWifiAdmin.createWifiInfo("YOU_WIFI","MM123456",WifiAdmin.TYPE_WPA));
}
});
mBtn2.setOnClickListener(newButton.OnClickListener(){
@Override
publicvoidonClick(Viewv){
//TODOAuto-generatedmethodstub
WifiApAdminwifiAp=newWifiApAdmin(mContext);
wifiAp.startWifiAp("\"HotSpot\"","hhhhhh123");
}
});
}
@Override
publicbooleanonCreateOptionsMenu(Menumenu){
//Inflatethemenu;thisaddsitemstotheactionbarifitispresent.
getMenuInflater().inflate(R.menu.activity_main,menu);
returntrue;
}
@Override
publicvoidonResume(){
super.onResume();
Log.d("Rssi","Registered");
}
@Override
publicvoidonPause(){
super.onPause();
Log.d("Rssi","Unregistered");
}
}
WifiAdmin.java
packagecom.widget.hotspot;
importjava.util.List;
importjava.util.Timer;
importjava.util.TimerTask;
importandroid.content.BroadcastReceiver;
importandroid.content.Context;
importandroid.content.Intent;
importandroid.content.IntentFilter;
importandroid.net.ConnectivityManager;
importandroid.net.NetworkInfo;
importandroid.net.NetworkInfo.DetailedState;
importandroid.net.wifi.ScanResult;
importandroid.net.wifi.WifiConfiguration;
importandroid.net.wifi.WifiInfo;
importandroid.net.wifi.WifiManager;
importandroid.net.wifi.WifiManager.WifiLock;
importandroid.util.Log;
publicabstractclassWifiAdmin{
privatestaticfinalStringTAG="WifiAdmin";
privateWifiManagermWifiManager;
privateWifiInfomWifiInfo;
//扫描出的网络连接列表
privateList<ScanResult>mWifiList;
privateList<WifiConfiguration>mWifiConfiguration;
privateWifiLockmWifiLock;
privateStringmPasswd="";
privateStringmSSID="";
privateContextmContext=null;
publicWifiAdmin(Contextcontext){
mContext=context;
//取得WifiManager对象
mWifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);
//取得WifiInfo对象
mWifiInfo=mWifiManager.getConnectionInfo();
Log.v(TAG,"getIpAddress="+mWifiInfo.getIpAddress());
}
//打开WIFI
publicvoidopenWifi(){
if(!mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(true);
}
}
//关闭WIFI
publicvoidcloseWifi(){
if(mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(false);
}
}
publicabstractIntentmyRegisterReceiver(BroadcastReceiverreceiver,IntentFilterfilter);
publicabstractvoidmyUnregisterReceiver(BroadcastReceiverreceiver);
publicabstractvoidonNotifyWifiConnected();
publicabstractvoidonNotifyWifiConnectFailed();
//添加一个网络并连接
publicvoidaddNetwork(WifiConfigurationwcg){
register();
WifiApAdmin.closeWifiAp(mContext);
intwcgID=mWifiManager.addNetwork(wcg);
booleanb=mWifiManager.enableNetwork(wcgID,true);
}
publicstaticfinalintTYPE_NO_PASSWD=0x11;
publicstaticfinalintTYPE_WEP=0x12;
publicstaticfinalintTYPE_WPA=0x13;
publicvoidaddNetwork(Stringssid,Stringpasswd,inttype){
if(ssid==null||passwd==null||ssid.equals("")){
Log.e(TAG,"addNetwork()##nullpointererror!");
return;
}
if(type!=TYPE_NO_PASSWD&&type!=TYPE_WEP&&type!=TYPE_WPA){
Log.e(TAG,"addNetwork()##unknowntype="+type);
}
stopTimer();
unRegister();
addNetwork(createWifiInfo(ssid,passwd,type));
}
privateBroadcastReceivermBroadcastReceiver=newBroadcastReceiver(){
@Override
publicvoidonReceive(Contextcontext,Intentintent){
//TODOAuto-generatedmethodstub
if(intent.getAction().equals(WifiManager.RSSI_CHANGED_ACTION)){
Log.d(TAG,"RSSIchanged");
//有可能是正在获取，或者已经获取了
Log.d(TAG,"intentis"+WifiManager.RSSI_CHANGED_ACTION);
if(isWifiContected(mContext)==WIFI_CONNECTED){
stopTimer();
onNotifyWifiConnected();
unRegister();
}elseif(isWifiContected(mContext)==WIFI_CONNECT_FAILED){
stopTimer();
closeWifi();
onNotifyWifiConnectFailed();
unRegister();
}elseif(isWifiContected(mContext)==WIFI_CONNECTING){
}
}
}
};
privatefinalintSTATE_REGISTRING=0x01;
privatefinalintSTATE_REGISTERED=0x02;
privatefinalintSTATE_UNREGISTERING=0x03;
privatefinalintSTATE_UNREGISTERED=0x04;
privateintmHaveRegister=STATE_UNREGISTERED;
privatesynchronizedvoidregister(){
Log.v(TAG,"register()##mHaveRegister="+mHaveRegister);
if(mHaveRegister==STATE_REGISTRING
||mHaveRegister==STATE_REGISTERED){
return;
}
mHaveRegister=STATE_REGISTRING;
myRegisterReceiver(mBroadcastReceiver,newIntentFilter(WifiManager.RSSI_CHANGED_ACTION));
mHaveRegister=STATE_REGISTERED;
startTimer();
}
privatesynchronizedvoidunRegister(){
Log.v(TAG,"unRegister()##mHaveRegister="+mHaveRegister);
if(mHaveRegister==STATE_UNREGISTERED
||mHaveRegister==STATE_UNREGISTERING){
return;
}
mHaveRegister=STATE_UNREGISTERING;
myUnregisterReceiver(mBroadcastReceiver);
mHaveRegister=STATE_UNREGISTERED;
}
privateTimermTimer=null;
privatevoidstartTimer(){
if(mTimer!=null){
stopTimer();
}
mTimer=newTimer(true);
//mTimer.schedule(mTimerTask,0,20*1000);//20s
mTimer.schedule(mTimerTask,30*1000);
}
privateTimerTaskmTimerTask=newTimerTask(){
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
Log.e(TAG,"timerout!");
onNotifyWifiConnectFailed();
unRegister();
}
};
privatevoidstopTimer(){
if(mTimer!=null){
mTimer.cancel();
mTimer=null;
}
}
@Override
protectedvoidfinalize(){
try{
super.finalize();
unRegister();
}catch(Throwablee){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
publicWifiConfigurationcreateWifiInfo(StringSSID,Stringpassword,inttype){
Log.v(TAG,"SSID="+SSID+"##Password="+password+"##Type="+type);
WifiConfigurationconfig=newWifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID="\""+SSID+"\"";
WifiConfigurationtempConfig=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;
}elseif(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;
}elseif(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;
}
returnconfig;
}
publicstaticfinalintWIFI_CONNECTED=0x01;
publicstaticfinalintWIFI_CONNECT_FAILED=0x02;
publicstaticfinalintWIFI_CONNECTING=0x03;
/**
*判断wifi是否连接成功,不是network
*
*@paramcontext
*@return
*/
publicintisWifiContected(Contextcontext){
ConnectivityManagerconnectivityManager=(ConnectivityManager)context
.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfowifiNetworkInfo=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){
returnWIFI_CONNECTING;
}elseif(wifiNetworkInfo.getDetailedState()==DetailedState.CONNECTED){
returnWIFI_CONNECTED;
}else{
Log.d(TAG,"getDetailedState()=="+wifiNetworkInfo.getDetailedState());
returnWIFI_CONNECT_FAILED;
}
}
privateWifiConfigurationIsExsits(StringSSID){
List<WifiConfiguration>existingConfigs=mWifiManager.getConfiguredNetworks();
for(WifiConfigurationexistingConfig:existingConfigs){
if(existingConfig.SSID.equals("\""+SSID+"\"")/*&&existingConfig.preSharedKey.equals("\""+password+"\"")*/){
returnexistingConfig;
}
}
returnnull;
}
//断开指定ID的网络
publicvoiddisconnectWifi(intnetId){
mWifiManager.disableNetwork(netId);
mWifiManager.disconnect();
}
//检查当前WIFI状态
publicintcheckState(){
returnmWifiManager.getWifiState();
}
//锁定WifiLock
publicvoidacquireWifiLock(){
mWifiLock.acquire();
}
//解锁WifiLock
publicvoidreleaseWifiLock(){
//判断时候锁定
if(mWifiLock.isHeld()){
mWifiLock.acquire();
}
}
//创建一个WifiLock
publicvoidcreatWifiLock(){
mWifiLock=mWifiManager.createWifiLock("Test");
}
//得到配置好的网络
publicList<WifiConfiguration>getConfiguration(){
returnmWifiConfiguration;
}
//指定配置好的网络进行连接
publicvoidconnectConfiguration(intindex){
//索引大于配置好的网络索引返回
if(index>mWifiConfiguration.size()){
return;
}
//连接配置好的指定ID的网络
mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,
true);
}
publicvoidstartScan(){
mWifiManager.startScan();
mWifiList=mWifiManager.getScanResults();
mWifiConfiguration=mWifiManager.getConfiguredNetworks();
}
//得到网络列表
publicList<ScanResult>getWifiList(){
returnmWifiList;
}
//查看扫描结果
publicStringBuilderlookUpScan(){
StringBuilderstringBuilder=newStringBuilder();
for(inti=0;i<mWifiList.size();i++){
stringBuilder
.append("Index_"+newInteger(i+1).toString()+":");
//将ScanResult信息转换成一个字符串包
//其中把包括：BSSID、SSID、capabilities、frequency、level
stringBuilder.append((mWifiList.get(i)).toString());
stringBuilder.append("/n");
}
returnstringBuilder;
}
//得到MAC地址
publicStringgetMacAddress(){
return(mWifiInfo==null)?"NULL":mWifiInfo.getMacAddress();
}
//得到接入点的BSSID
publicStringgetBSSID(){
return(mWifiInfo==null)?"NULL":mWifiInfo.getBSSID();
}
//得到IP地址
publicintgetIPAddress(){
return(mWifiInfo==null)?0:mWifiInfo.getIpAddress();
}
//得到连接的ID
publicintgetNetworkId(){
return(mWifiInfo==null)?0:mWifiInfo.getNetworkId();
}
//得到WifiInfo的所有信息包
publicStringgetWifiInfo(){
return(mWifiInfo==null)?"NULL":mWifiInfo.toString();
}
}
WifiApAdmin.java
packagecom.widget.hotspot;
importjava.lang.reflect.InvocationTargetException;
importjava.lang.reflect.Method;
importjava.util.Timer;
importjava.util.TimerTask;
importandroid.content.Context;
importandroid.net.wifi.WifiConfiguration;
importandroid.net.wifi.WifiManager;
importandroid.util.Log;
/**
*创建热点
*
*/
publicclassWifiApAdmin{
publicstaticfinalStringTAG="WifiApAdmin";
publicstaticvoidcloseWifiAp(Contextcontext){
WifiManagerwifiManager=(WifiManager)context.getSystemService(Context.WIFI_SERVICE);
closeWifiAp(wifiManager);
}
privateWifiManagermWifiManager=null;
privateContextmContext=null;
publicWifiApAdmin(Contextcontext){
mContext=context;
mWifiManager=(WifiManager)mContext.getSystemService(Context.WIFI_SERVICE);
closeWifiAp(mWifiManager);
}
privateStringmSSID="";
privateStringmPasswd="";
publicvoidstartWifiAp(Stringssid,Stringpasswd){
mSSID=ssid;
mPasswd=passwd;
if(mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(false);
}
stratWifiAp();
MyTimerChecktimerCheck=newMyTimerCheck(){
@Override
publicvoiddoTimerCheckWork(){
//TODOAuto-generatedmethodstub
if(isWifiApEnabled(mWifiManager)){
Log.v(TAG,"Wifienabledsuccess!");
this.exit();
}else{
Log.v(TAG,"Wifienabledfailed!");
}
}
@Override
publicvoiddoTimeOutWork(){
//TODOAuto-generatedmethodstub
this.exit();
}
};
timerCheck.start(15,1000);
}
publicvoidstratWifiAp(){
Methodmethod1=null;
try{
method1=mWifiManager.getClass().getMethod("setWifiApEnabled",
WifiConfiguration.class,boolean.class);
WifiConfigurationnetConfig=newWifiConfiguration();
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(IllegalArgumentExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IllegalAccessExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(InvocationTargetExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(SecurityExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(NoSuchMethodExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
privatestaticvoidcloseWifiAp(WifiManagerwifiManager){
if(isWifiApEnabled(wifiManager)){
try{
Methodmethod=wifiManager.getClass().getMethod("getWifiApConfiguration");
method.setAccessible(true);
WifiConfigurationconfig=(WifiConfiguration)method.invoke(wifiManager);
Methodmethod2=wifiManager.getClass().getMethod("setWifiApEnabled",WifiConfiguration.class,boolean.class);
method2.invoke(wifiManager,config,false);
}catch(NoSuchMethodExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IllegalArgumentExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IllegalAccessExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(InvocationTargetExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
privatestaticbooleanisWifiApEnabled(WifiManagerwifiManager){
try{
Methodmethod=wifiManager.getClass().getMethod("isWifiApEnabled");
method.setAccessible(true);
return(Boolean)method.invoke(wifiManager);
}catch(NoSuchMethodExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(Exceptione){
e.printStackTrace();
}
returnfalse;
}
}
MyTimeCheck.java
packagecom.widget.hotspot;
publicabstractclassMyTimerCheck{
privateintmCount=0;
privateintmTimeOutCount=1;
privateintmSleepTime=1000;//1s
privatebooleanmExitFlag=false;
privateThreadmThread=null;
/**
*DonotprocessUIworkinthis.
*/
publicabstractvoiddoTimerCheckWork();
publicabstractvoiddoTimeOutWork();
publicMyTimerCheck(){
mThread=newThread(newRunnable(){
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
while(!mExitFlag){
mCount++;
if(mCount<mTimeOutCount){
doTimerCheckWork();
try{
mThread.sleep(mSleepTime);
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
exit();
}
}else{
doTimeOutWork();
}
}
}
});
}
/**
*start
*@paramtimesHowmanytimeswillcheck?
*@paramsleepTimems,Everychecksleeptime.
*/
publicvoidstart(inttimeOutCount,intsleepTime){
mTimeOutCount=timeOutCount;
mSleepTime=sleepTime;
mThread.start();
}
publicvoidexit(){
mExitFlag=true;
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。