android wifi开发

这个小项目实现了，WiFi的开关、获取WiFi扫描列表、获取保存的WiFi列表、连接WiFi、获取WiFi连接的各种状态。利用接口回调实现活动与广播的通信。下面是一张效果图。



使用WiFi需要这么几个权限。

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

简单说一下几个比较容易出问题的地方，WiFi扫描获取WiFi列表的时候，一定要注册了一个监听扫描完成的广播，虽然不监听广播也能获取的列表，但是你不知道它什么时候扫描完的，而且WiFi是会自己不断的扫描的，监听广播也就可以像手机WiFi那样自动的刷新列表了。连接WiFi的时候要根据WiFi锁的类型来连接（一般是psk），代码中有给出。WiFimanager有多个广播，通过监听广播得到很多信息代码中没有给出全部，可以参考文档：http://www.android-doc.com/reference/android/net/wifi/WifiManager.html 然后关于连接状态，代码中给了几个常见的身份验证、获取ID、连接失败什么的。这些状态都在networkinfo中，如需要获取其他信息查看这个类的DetailedState：http://www.android-doc.com/reference/android/net/NetworkInfo.html。关于活动去广播通信，最常用的是接口回调（我这里用的就是接口回调），当然还有其他的方式，如静态变量（需要主活动开个线程一直去读这个变量），广播接收器里面再发送一个简单的广播给活动（毕竟广播经常用来通信）。
给个项目的下载地址：http://download.csdn.net/download/lhp15575865420/10040883

public class MainActivity extends AppCompatActivity {

private Button button1;
private Button button2;
private Button button3;
private MyAdapter myAdapter;
private LinkedList<Data> datas;
private RecyclerView recycle;

private WifiManager wifiManager;
private WifiInfo wifiInfo;
private Mywifi mywifi;
private List<ScanResult> results;
private List<WifiConfiguration> configurations;
private  WifiReceiver wifiReceiver;

private final int SCANRE=1;//搜索到WiFi列表标志
private final int CONFIG=2;//连接过WiFi列表标志
private static int change=1;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

button1= (Button) findViewById(R.id.button1);
button2= (Button) findViewById(R.id.button2);
button3= (Button) findViewById(R.id.button3);
initRecyclerView();

mywifi=new Mywifi(MainActivity.this);
initReceiver();
somelisten();
}

public void initRecyclerView(){
recycle= (RecyclerView) findViewById(R.id.recycle);
datas=new LinkedList<Data>();
datas.add(new Data("WiFI名字","物理地址"));
myAdapter=new MyAdapter(datas,MainActivity.this);
//设置布局为线性布局，默认竖直
recycle.setLayoutManager(new LinearLayoutManager(this));
recycle.setAdapter(myAdapter);
//设置添加和删除的动画效果
recycle.setItemAnimator(new DefaultItemAnimator());
//设置横向分割线
recycle.addItemDecoration(new DividerItemDecoration(MainActivity.this, LinearLayoutManager.VERTICAL));
}

public void somelisten(){
button1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
switch (mywifi.checkwifistate()){
case 0:
Toast.makeText(MainActivity.this,"WiFi正在关闭",Toast.LENGTH_SHORT).show();
break;
case 1:
mywifi.openwifi();
break;
case 2:
Toast.makeText(MainActivity.this,"WiFi正在打开",Toast.LENGTH_SHORT).show();
break;
case 3:
mywifi.closewifi();
break;
}
}
});

button2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(change==SCANRE){
myAdapter.removeAll();
configurations=mywifi.getConfigurations();
if(configurations!=null)
for(int i=0;i<configurations.size();i++){
myAdapter.add(new Data(configurations.get(i).SSID,
"物理地址不确定"));
}
change=CONFIG;
}else{
myAdapter.removeAll();
results=mywifi.getWifilist();
for(int i=0;i<results.size();i++){
myAdapter.add(new Data(results.get(i).SSID,
results.get(i).BSSID));
}
change=SCANRE;
}
}
});
button3.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mywifi.closeconnect();
}
});
myAdapter.setOnItemClickListener(new MyAdapter.OnItemClickListener() {
@Override
public void onItemClick(View view, int postion) {
if(results==null) return;
if(change==CONFIG){
Toast.makeText(MainActivity.this,"只能连接搜索到的WiFi",Toast.LENGTH_SHORT).show();
return;
}
Toast.makeText(MainActivity.this,results.get(postion).toString(),Toast.LENGTH_SHORT).show();
mywifi.wificonnect(results.get(postion),"12345678");//假设密码是12345678
}

@Override
public void onItemLongClick(View view, int postion) {
}
});
}

public void initReceiver(){
wifiReceiver=new WifiReceiver();
IntentFilter intentFilter=new IntentFilter();
intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
intentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
registerReceiver(wifiReceiver,intentFilter);
//回调接口监听
wifiReceiver.setMsglistener(new WifiReceiver.Msg() {
@Override
public void getmsg(String msg) {
if(msg.equals("ok")){
myAdapter.removeAll();
results=mywifi.getWifilist();
Log.e("扫描结果", String.valueOf(results.size()));
for(int i=0;i<results.size();i++){
myAdapter.add(new Data( results.get(i).SSID,
results.get(i).BSSID));
}
}
}
});
}

@Override
protected void onDestroy() {
super.onDestroy();
unregisterReceiver(wifiReceiver);
}
}

public class Mywifi {
private WifiManager wifiManager;//WiFi管理器
privat
4000
e WifiInfo wifiInfo;
private List<ScanResult> wifilist;//扫描到的WiFi列表
private List<WifiConfiguration> configurations;//配置好(连接过)的WiFi列表
//锁屏后，其他程序没有用到WiFi，过一会WiFi会自动关闭，加WiFi后则不会
private WifiManager.WifiLock lock;//wifi锁。

public Mywifi(Context context) {
wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
lock=wifiManager.createWifiLock(2,"mylock");
/*locktype 1:会自动连接一个记住的接入点。没有连接到记住的接入点的时候，自动扫描，
2：只扫描，在这种模式下，程序必须显示地请求扫描
3：以最好的性能执行1
*/
}
//打开WiFi，锁定WiFi,扫描WiFi
public void openwifi(){
if(!wifiManager.isWifiEnabled()){
wifiManager.setWifiEnabled(true);
Log.e("Wifi","打开WiFi");
lock.acquire();
}
scan();
}
//扫描WiFi
public void scan(){wifiManager.startScan();}
//关闭WiFi
public void closewifi(){
if(wifiManager.isWifiEnabled()){
wifiManager.setWifiEnabled(false);
}
}
//检查WiFi状态
public int checkwifistate(){
//0:wifi正在关闭。1：WiFi已经关闭。2：WiFi正在开启。3：WiFi已经开启
return wifiManager.getWifiState();
}
//获取搜索到的WiFi列表
public List<ScanResult> getWifilist(){
wifilist=wifiManager.getScanResults();
return wifilist;
}
//获取连接过的WiFi列表
public List<WifiConfiguration> getConfigurations(){
configurations=wifiManager.getConfiguredNetworks();
return configurations;
}
//连接指定WiFi
public void wificonnect(ScanResult scan,String password){
WifiConfiguration config=new WifiConfiguration();
//对config初始化，将他的各个参数清空
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();

config.SSID=scan.SSID;//通过ssid来标识一个WiFi
Log.e("WiFi连接",scan.SSID);

//判断锁的类型。通过scanresult的结果是否含有某些值来确定
//根据锁的类型来设置某些参数
if(scan.capabilities.contains("WEP")){
Log.e("WiFi连接","wep加密");
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
//            config.allowedAuthAlgorithms.set(WifiConfiguration.GroupCipher.WEP40);
//            config.allowedAuthAlgorithms.set(WifiConfiguration.GroupCipher.CCMP);
//            config.allowedAuthAlgorithms.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
config.wepTxKeyIndex=0;
config.wepKeys[0]=password;
}else if(scan.capabilities.contains("PSK")){
Log.e("WiFi连接","psk加密");
config.preSharedKey="\""+password+"\"";
}else if(scan.capabilities.contains("EAP")){
Log.e("WiFi连接","eap加密");
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
config.allowedAuthAlgorithms.set(WifiConfiguration.GroupCipher.TKIP);
config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
config.preSharedKey="\""+password+"\"";
}else {//没有加密
Log.e("WiFi连接","没有加密");
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
//config.wepTxKeyIndex=0;
//config.wepKeys[0]="";
}

int i=wifiManager.addNetwork(config);//连接到WiFi。
Log.e("连接结果", String.valueOf(i));
}
//断开连接
public void closeconnect(){
//wifiManager.disconnect();
wifiInfo=wifiManager.getConnectionInfo();//获取当前连接
int netid=wifiInfo.getNetworkId();
wifiManager.disableNetwork(netid);

}
}

public class WifiReceiver extends BroadcastReceiver{
private Msg msg;//与activity通信

@Override
public void onReceive(Context context, Intent intent) {
String action=intent.getAction();
Log.e("action",action);
if(WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)){
int wifistate=intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE,WifiManager.WIFI_STATE_DISABLED);
if(wifistate==WifiManager.WIFI_STATE_ENABLED) {
Log.e("广播wifistate", "wifi打开");
}
if(wifistate==WifiManager.WIFI_STATE_DISABLED) Log.e("广播wifistate","wifi关闭");
}
else if(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(action)){
Log.e("广播sacn","wifi扫描完成");
msg.getmsg("ok");
}
else if(WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)){
NetworkInfo info=intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
if(info.getState().equals(NetworkInfo.State.DISCONNECTED)) Log.e("广播Network","WiFi网络连接断开");
if(info.getState().equals(NetworkInfo.State.CONNECTED)) Log.e("广播Network","连接到WiFi网络");

if(info.getDetailedState().equals(NetworkInfo.DetailedState.OBTAINING_IPADDR)) Log.e("广播Network","获取IP地址中");
if(info.getDetailedState().equals(NetworkInfo.DetailedState.DISCONNECTED)) Log.e("广播Network","ip不可用");
if(info.getDetailedState().equals(NetworkInfo.DetailedState.SCANNING)) Log.e("广播Network","正在扫描");
if(info.getDetailedState().equals(NetworkInfo.DetailedState.AUTHENTICATING)) Log.e("广播Network","身份验证中");
if(info.getDetailedState().equals(NetworkInfo.DetailedState.FAILED))  Log.e("广播Network","连接失败");
//http://www.android-doc.com/reference/android/net/NetworkInfo.html
}
//http://www.android-doc.com/reference/android/net/wifi/WifiManager.html
}

//通过接口实现与activity之间的通信
public interface Msg{
public void getmsg(String msg);
}
public void setMsglistener(Msg msg){
this.msg=msg;
}
}