Android开发_Wifi(一)

最新推荐文章于 2022-06-02 19:54:57 发布

张腾元-Ternence

最新推荐文章于 2022-06-02 19:54:57 发布

阅读量2.8k

点赞数

分类专栏： Android Dev 文章标签： Android 安卓 wifi 开发

本文链接：https://blog.csdn.net/zhangtengyuan23/article/details/8560305

版权

Android Dev 专栏收录该内容

83 篇文章 0 订阅

订阅专栏

Android Wifi 操作

在Android中对Wifi操作，android本身提供了一些有用的包，在android.net.wifi包下面。主要包括以下几个类和接口：

1.ScanResult

主要用来描述已经检测出的接入点，包括接入点的地址，接入点的名称，身份认证，频率，信号强度等信息。

2.WifiConfiguration

Wifi网络的配置，包括安全设置等。

3.WifiInfo

wifi无线连接的描述，包括接入点，网络连接状态，隐藏的接入点，IP地址，连接速度，MAC地址，网络ID，信号强度等信息。这里简单介绍一下这里的方法:

getBSSID() 获取BSSID

getDetailedStateOf() 获取客户端的连通性

getHiddenSSID() 获得SSID 是否被隐藏

getIpAddress() 获取IP 地址

getLinkSpeed() 获得连接的速度

getMacAddress() 获得Mac 地址

getRssi() 获得802.11n 网络的信号

getSSID() 获得SSID

getSupplicanState() 返回具体客户端状态的信息

4.WifiManager

这个不用说，就是用来管理我们的wifi 连接，这里已经定义好了一些类，可以供我们使用。

获取WIFI网卡的状态

　　WIFI网卡的状态是由一系列的整形常量来表示的。

　　1.WIFI_STATE_DISABLED : WIFI网卡不可用（1）

　　2.WIFI_STATE_DISABLING : WIFI网卡正在关闭（0）

　　3.WIFI_STATE_ENABLED : WIFI网卡可用（3）

　　4.WIFI_STATE_ENABLING : WIFI网正在打开（2）（WIFI启动需要一段时间）

　　5.WIFI_STATE_UNKNOWN : 未知网卡状态

二-----

1、AndroidMainifest.xml中添加permission

<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

2、 Activity主程序WifiActivity中设置三个按键，Start，Stop， State（查看状态）

3、 public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_wifi);
//start UI
Start = (Button)findViewById(R.id.start);
Stop = (Button)findViewById(R.id.stop);
State = (Button)findViewById(R.id.state);

//Methods
//Set Wifi enable
Start.setOnClickListener(new OnClickListener() {

public void onClick(View arg0) {

WifiManager wifi = (WifiManager) WifiActivity.this.getSystemService(WIFI_SERVICE);
wifi.setWifiEnabled(true);
System.out.println("Wifi_State -------> " + wifi.getWifiState());
}
});

//Stop wifi
Stop.setOnClickListener(new OnClickListener() {

public void onClick(View v) {
WifiManager wifi = (WifiManager) WifiActivity.this.getSystemService(WIFI_SERVICE);
wifi.setWifiEnabled(false);
System.out.println("Wifi_State -------> " + wifi.getWifiState());
}
});

//Show wifi state
State.setOnClickListener(new OnClickListener() {

public void onClick(View v) {
WifiManager wifi = (WifiManager) WifiActivity.this.getSystemService(WIFI_SERVICE);

System.out.println("Wifi_State -------> " + wifi.getWifiState());
}
});

}

//完成基本的打开，关闭，查看状态功能

4、WifiManager 的建立

Context.getSystemService(Context.WIFI_SERVICE)

在activity中我们用 WifiActivity.this.getSystemService(WIFI_SERVICE)

（activity 继承自 context；）

public class

WifiManager

extends Object

java.lang.Object
↳	android.net.wifi.WifiManager

Class Overview

This class provides the primary API for managing all aspects of Wi-Fi connectivity. Get an instance of this class by callingContext.getSystemService(Context.WIFI_SERVICE). It deals with several categories of items:

5、

Public Methods
int	addNetwork(WifiConfiguration config) Add a new network description to the set of configured networks.
static int	calculateSignalLevel(int rssi, int numLevels) Calculates the level of the signal.
static int	compareSignalLevel(int rssiA, int rssiB) Compares two signal strengths.
WifiManager.MulticastLock	createMulticastLock(String tag) Create a new MulticastLock
WifiManager.WifiLock	createWifiLock(int lockType, String tag) Creates a new WifiLock.
WifiManager.WifiLock	createWifiLock(String tag) Creates a new WifiLock.
boolean	disableNetwork(int netId) Disable a configured network.
boolean	disconnect() Disassociate from the currently active access point.
boolean	enableNetwork(int netId, boolean disableOthers) Allow a previously configured network to be associated with.
List<WifiConfiguration>	getConfiguredNetworks() Return a list of all the networks configured in the supplicant.
WifiInfo	getConnectionInfo() Return dynamic information about the current Wi-Fi connection, if any is active.
DhcpInfo	getDhcpInfo() Return the DHCP-assigned addresses from the last successful DHCP request, if any.
List<ScanResult>	getScanResults() Return the results of the latest access point scan.
int	getWifiState() Gets the Wi-Fi enabled state.
boolean	isWifiEnabled() Return whether Wi-Fi is enabled or disabled.
boolean	pingSupplicant() Check that the supplicant daemon is responding to requests.
boolean	reassociate() Reconnect to the currently active access point, even if we are already connected.
boolean	reconnect() Reconnect to the currently active access point, if we are currently disconnected.
boolean	removeNetwork(int netId) Remove the specified network from the list of configured networks.
boolean	saveConfiguration() Tell the supplicant to persist the current list of configured networks.
boolean	setWifiEnabled(boolean enabled) Enable or disable Wi-Fi.
boolean	startScan() Request a scan for access points.
int	updateNetwork(WifiConfiguration config) Update the network description of an existing configured network.

Protected Methods
void	finalize() Invoked when the garbage collector has detected that this instance is no longer reachable.

三、

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<LinearLayout
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<Button
android:id="@+id/scan"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="扫描网络"
/>
<Button
android:id="@+id/start"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="打开Wifi"
/>
<Button
android:id="@+id/stop"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="关闭Wifi"
/>
<Button
android:id="@+id/check"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Wifi状态"
/>
<TextView
android:id="@+id/allNetWork"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="当前没有扫描到Wifi网络"
/>
</LinearLayout>
</ScrollView>

import java.util.List;
import android.content.Context;
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;
public class WifiAdmin {
//定义一个WifiManager对象
private WifiManager mWifiManager;
//定义一个WifiInfo对象
private WifiInfo mWifiInfo;
//扫描出的网络连接列表
private List<ScanResult> mWifiList;
//网络连接列表
private List<WifiConfiguration> mWifiConfigurations;
WifiLock mWifiLock;
public WifiAdmin(Context context){
//取得WifiManager对象
mWifiManager=(WifiManager) context.getSystemService(Context.WIFI_SERVICE);
//取得WifiInfo对象
mWifiInfo=mWifiManager.getConnectionInfo();
}
//打开wifi
public void openWifi(){
if(!mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(true);
}
}
//关闭wifi
public void closeWifi(){
if(!mWifiManager.isWifiEnabled()){
mWifiManager.setWifiEnabled(false);
}
}
// 检查当前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 createWifiLock(){
mWifiLock=mWifiManager.createWifiLock("test");
}
//得到配置好的网络
public List<WifiConfiguration> getConfiguration(){
return mWifiConfigurations;
}
//指定配置好的网络进行连接
public void connetionConfiguration(int index){
if(index>mWifiConfigurations.size()){
return ;
}
//连接配置好指定ID的网络
mWifiManager.enableNetwork(mWifiConfigurations.get(index).networkId, true);
}
public void startScan(){
mWifiManager.startScan();
//得到扫描结果
mWifiList=mWifiManager.getScanResults();
//得到配置好的网络连接
mWifiConfigurations=mWifiManager.getConfiguredNetworks();
}
//得到网络列表
public List<ScanResult> getWifiList(){
return mWifiList;
}
//查看扫描结果
public StringBuffer lookUpScan(){
StringBuffer sb=new StringBuffer();
for(int i=0;i<mWifiList.size();i++){
sb.append("Index_" + new Integer(i + 1).toString() + ":");
// 将ScanResult信息转换成一个字符串包
// 其中把包括：BSSID、SSID、capabilities、frequency、level
sb.append((mWifiList.get(i)).toString()).append("\n");
}
return sb;
}
public String getMacAddress(){
return (mWifiInfo==null)?"NULL":mWifiInfo.getMacAddress();
}
public String getBSSID(){
return (mWifiInfo==null)?"NULL":mWifiInfo.getBSSID();
}
public int getIpAddress(){
return (mWifiInfo==null)?0:mWifiInfo.getIpAddress();
}
//得到连接的ID
public int getNetWordId(){
return (mWifiInfo==null)?0:mWifiInfo.getNetworkId();
}
//得到wifiInfo的所有信息
public String getWifiInfo(){
return (mWifiInfo==null)?"NULL":mWifiInfo.toString();
}
//添加一个网络并连接
public void addNetWork(WifiConfiguration configuration){
int wcgId=mWifiManager.addNetwork(configuration);
mWifiManager.enableNetwork(wcgId, true);
}
//断开指定ID的网络
public void disConnectionWifi(int netId){
mWifiManager.disableNetwork(netId);
mWifiManager.disconnect();
}
}

WifiActivity类：

[html] view plain copy

import java.util.List;
import android.app.Activity;
import android.net.wifi.ScanResult;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
public class WifiActivity extends Activity {
/** Called when the activity is first created. */
private TextView allNetWork;
private Button scan;
private Button start;
private Button stop;
private Button check;
private WifiAdmin mWifiAdmin;
// 扫描结果列表
private List<ScanResult> list;
private ScanResult mScanResult;
private StringBuffer sb=new StringBuffer();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
mWifiAdmin = new WifiAdmin(WifiActivity.this);
init();
}
public void init(){
allNetWork = (TextView) findViewById(R.id.allNetWork);
scan = (Button) findViewById(R.id.scan);
start = (Button) findViewById(R.id.start);
stop = (Button) findViewById(R.id.stop);
check = (Button) findViewById(R.id.check);
scan.setOnClickListener(new MyListener());
start.setOnClickListener(new MyListener());
stop.setOnClickListener(new MyListener());
check.setOnClickListener(new MyListener());
}
private class MyListener implements OnClickListener{
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
switch (v.getId()) {
case R.id.scan://扫描网络
getAllNetWorkList();
break;
case R.id.start://打开Wifi
mWifiAdmin.openWifi();
Toast.makeText(WifiActivity.this, "当前wifi状态为："+mWifiAdmin.checkState(), 1).show();
break;
case R.id.stop://关闭Wifi
mWifiAdmin.closeWifi();
Toast.makeText(WifiActivity.this, "当前wifi状态为："+mWifiAdmin.checkState(), 1).show();
break;
case R.id.check://Wifi状态
Toast.makeText(WifiActivity.this, "当前wifi状态为："+mWifiAdmin.checkState(), 1).show();
break;
default:
break;
}
}
}
public void getAllNetWorkList(){
// 每次点击扫描之前清空上一次的扫描结果
if(sb!=null){
sb=new StringBuffer();
}
//开始扫描网络
mWifiAdmin.startScan();
list=mWifiAdmin.getWifiList();
if(list!=null){
for(int i=0;i<list.size();i++){
//得到扫描结果
mScanResult=list.get(i);
sb=sb.append(mScanResult.BSSID+" ").append(mScanResult.SSID+" ")
.append(mScanResult.capabilities+" ").append(mScanResult.frequency+" ")
.append(mScanResult.level+"\n\n");
}
allNetWork.setText("扫描到的wifi网络：\n"+sb.toString());
}
}
}

<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"></uses-permission>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>

经过查看网上的资料，知道在手机屏幕关闭之后，并且其他的应用程序没有在使用wifi的时候，系统大概在两分钟之后，会关闭wifi，使得wifi处于睡眠状态。

这样的做法，有利于电源能量的节省和延长电池寿命等。

android为wifi提供了一种叫WifiLock的锁，能够阻止wifi进入睡眠状态，使wifi一直处于活跃状态。这种锁，在下载一个较大的文件的时候，比较适合使用。

WifiLock Allows an application to keep the Wi-Fi radio awake.

一、创建一个wifiLock

[java] view plain copy

/**
*
* @param lockName
* 锁的名字
* @return wifiLock
*/
public WifiLock createWifiLock(String lockName)
{
wifiLock = wifiManager.createWifiLock(lockName);
return wifiLock;
}

[java] view plain copy

/**
*
* @param lockName
* 锁的名称
* @param lockType
*
* WIFI_MODE_FULL == 1 <br/>
* 扫描，自动的尝试去连接一个曾经配置过的点<br />
* WIFI_MODE_SCAN_ONLY == 2 <br/>
* 只剩下扫描<br />
* WIFI_MODE_FULL_HIGH_PERF = 3 <br/>
* 在第一种模式的基础上，保持最佳性能<br />
* @return wifiLock
*/
public WifiLock createWifiLock(String lockName, int lockType)
{
wifiLock = wifiManager.createWifiLock(lockType, lockName);
return wifiLock;
}

二、给wifi添加锁

[java] view plain copy

/**
* 加上锁
*/
public void lockWifi()
{
wifiLock.acquire();
}

三、给wifi释放锁

[java] view plain copy

/**
* 释放锁
*/
public void releaseLock()
{
if (wifiLock.isHeld())
{
wifiLock.release();
}
}

四、判断wifi是否被lock锁持用

[java] view plain copy

/**
* 判断wifi的锁是否持有
*
* @return
*/
public boolean isHeld()
{
return wifiLock.isHeld();
}

关于自动连接wifi

在这篇文章中，作者定义了一个wifi工具类，其中存在着操作wifi的各种方法，其中有一些错误我以改正，正确的代码如下（创建一个名为WifiAdmin.java的文件，以下代码中没有包声明和import，请自行添加）：

[java]
public class WifiAdmin {
    // 定义WifiManager对象
    private WifiManager mWifiManager;
    // 定义WifiInfo对象
    private WifiInfo mWifiInfo;
    // 扫描出的网络连接列表
    private List<ScanResult> mWifiList;
    // 网络连接列表
    private List<WifiConfiguration> mWifiConfiguration;
    // 定义一个WifiLock
    WifiLock mWifiLock;


    // 构造器
    public WifiAdmin(Context context) {
        // 取得WifiManager对象
        mWifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        // 取得WifiInfo对象
        mWifiInfo = mWifiManager.getConnectionInfo();
    }

    // 打开WIFI
    public void openWifi() {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    // 关闭WIFI
    public void closeWifi() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    // 检查当前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();
    }

    // 添加一个网络并连接
    public void addNetwork(WifiConfiguration wcg) {
     int wcgID = mWifiManager.addNetwork(wcg);
     boolean b = mWifiManager.enableNetwork(wcgID, true);
     System.out.println("a--" + wcgID);
     System.out.println("b--" + b);
    }

    // 断开指定ID的网络
    public void disconnectWifi(int netId) {
        mWifiManager.disableNetwork(netId);
        mWifiManager.disconnect();
    }

//然后是一个实际应用方法，只验证过没有密码的情况：

    public WifiConfiguration CreateWifiInfo(String SSID, String Password, int 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);
          }

          if(Type == 1) //WIFICIPHER_NOPASS
          {
               config.wepKeys[0] = "";
               config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
               config.wepTxKeyIndex = 0;
          }
          if(Type == 2) //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;
          }
          if(Type == 3) //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;
    }

    private WifiConfiguration IsExsits(String SSID)
    {
        List<WifiConfiguration> existingConfigs = mWifiManager.getConfiguredNetworks();
           for (WifiConfiguration existingConfig : existingConfigs)
           {
             if (existingConfig.SSID.equals("\""+SSID+"\""))
             {
                 return existingConfig;
             }
           }
        return null;
    }

}
//分为三种情况：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密码验证。
最后就是在Manifest中添加相应的权限了：

[java]
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" ></uses-permission>
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" ></uses-permission>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" ></uses-permission>
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" ></uses-permission>

如果按照上述的方法进行开发，就可以很傻瓜的通过改变Test_wifiActivity.java中的CreateWifiInfo方法的三个入口参数实现加入指定SSID的wifi热点了，无论该热点是否需要密码认证。
以上就是我对于自动连接指定SSID的wifi热点的学习心得，