android WIFI to unity

来源：互联网发布：网络推广效果评估编辑：程序博客网时间：2024/06/08 07:30

本案例实现安卓自动搜索附近wifi和连接wifi，参考了网上很多人的做法，最终总结出来的一套个人觉得比较清晰的案例，给大家分享一下，最终做成jar包给unity服务。

一：wifi涉及到的权限

<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />允许程序改变网络连接状态
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" /> 允许程序改变Wi-Fi连接状态
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> 获取网络信息状态
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> 获取当前WiFi接入的状态以及WLAN热点的信息
<uses-permission android:name="android.permission.WAKE_LOCK" /> 允许使用PowerManager的 WakeLocks保持进程在休眠时从屏幕消失

<uses-permission android:name="android.permission.INTERNET" /> 访问网络连接

二：android系统相关wifi类

WifiManager

wifi管理的API，包括wifi的扫描，建立连接，配置，断开连接等等。

wifiManager.isWifiEnabled();//判断是否开启

wifiManager.setWifiEnabled(true);//设置开启关闭

注意，调用setWifiEnabled后，系统进行wifi模块的开启需要一定时间，此时通过wifiManager.getWifiState()获取的状态来判断是否完成。

WifiManager.WIFI_STATE_DISABLED : WIFI网卡不可用（1）
WifiManager.WIFI_STATE_DISABLING : WIFI网卡正在关闭（0）
WifiManager.WIFI_STATE_ENABLED : WIFI网卡可用（3）
WifiManager.WIFI_STATE_ENABLING : WIFI网正在打开（2）（WIFI启动需要一段时间）
WifiManager.WIFI_STATE_UNKNOWN : 未知网卡状态

具体参考：http://developer.android.com/reference/android/net/wifi/WifiManager.html

WifiInfo

描述已经建立连接的wifi信息。包括ip，mac地址，连接速度

具体参考：http://developer.android.com/reference/android/net/wifi/WifiInfo.html

ConnectivityManager

监控网络连接，当网络连接发生变化时返送广播，当一个网络请求连接失败的时候他会自动转到其他可连接网络等等

获取方式Context.getSystemService(Context.CONNECTIVITY_SERVICE)

具体参考：https://developer.android.com/reference/android/net/ConnectivityManager.html

WifiLock (WifiManager.WifiLock)

它是wifiManager里面的一个类。服务于WifiManager。当无线wifi有一段事件没用的时候系统可能会自动关闭，WifiLock 可以让无线wifi保持唤醒状态

具体参考：https://developer.android.com/reference/android/net/wifi/WifiManager.WifiLock.html

ScanResult（包是：android.net.wifi。不要import错包，因为蓝牙包中android.blutooth.le也有这个类）

开启扫描后搜索到的wifi热点的信息，包括SSID，Capbilities，frequency，level等等

具体介绍参考：http://developer.android.com/reference/android/net/wifi/ScanResult.html

WifiConfiguration

描述wifi的连接信息，包括SSID，SSID隐藏，password等等设置。

具体介绍参考：https://developer.android.com/reference/android/net/wifi/WifiConfiguration.html

二：android工程（报名也要修改成unity工程包名字）

1：PTWifiConnect

package com.yxh.wifi;

import java.util.List;

import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;

public class PTWifiConnect {
WifiManager wifiManager;
//wifi连接类型
public enum WifiCipherType{
WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
}
public PTWifiConnect(WifiManager wifiManager){
this.wifiManager = wifiManager;
}
private boolean openWifi() {
boolean bRet = true;
if (!wifiManager.isWifiEnabled()) {
bRet = wifiManager.setWifiEnabled(true);
}
return bRet;
}
public boolean connect(String SSID, String Password, WifiCipherType Type) {
if (!this.openWifi()) {
return false;
}
while (wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING) {
try {
Thread.currentThread();
Thread.sleep(100);
} catch (InterruptedException ie) {
}
}
WifiConfiguration wifiConfig = this
.createWifiInfo(SSID, Password, Type);
//
if (wifiConfig == null) {
return false;
}
WifiConfiguration tempConfig = this.isExsits(SSID);
if (tempConfig != null) {
wifiManager.removeNetwork(tempConfig.networkId);
}
int netID = wifiManager.addNetwork(wifiConfig);
boolean bRet = wifiManager.enableNetwork(netID, false);
return bRet;
}
private WifiConfiguration isExsits(String SSID) {
List<WifiConfiguration> existingConfigs = wifiManager
.getConfiguredNetworks();
for (WifiConfiguration existingConfig : existingConfigs) {
if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
return existingConfig;
}
}
return null;
}
private WifiConfiguration createWifiInfo(String SSID, String Password,
WifiCipherType Type) {
WifiConfiguration config = new WifiConfiguration();
config.allowedAuthAlgorithms.clear();
config.allowedGroupCiphers.clear();
config.allowedKeyManagement.clear();
config.allowedPairwiseCiphers.clear();
config.allowedProtocols.clear();
config.SSID = "\"" + SSID + "\"";
if (Type == WifiCipherType.WIFICIPHER_NOPASS) {
config.wepKeys[0] = "";
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.wepTxKeyIndex = 0;
}
if (Type == WifiCipherType.WIFICIPHER_WEP) {
config.preSharedKey = "\"" + Password + "\"";
config.hiddenSSID = true;
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 == WifiCipherType.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.status = WifiConfiguration.Status.ENABLED;
} else {
return null;
}
return config;
}
}

2：PTWifiAdministrator （这个类的255行被我写死了wifi密码，注意修改成自己的wifi密码）

package com.yxh.wifi;;
import java.net.Inet4Address;
import java.util.List;
import com.putao.circuit.cnpaigo.PTWifiConnect.WifiCipherType;
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 PTWifiAdministrator {

private WifiManager wifiManager; //wifi管理api
private WifiInfo wifiInfo; //具体wifi数据api
private List<ScanResult> scanResultList; //wifi扫描结果
private List<WifiConfiguration> wifiConfigurationList;

WifiLock wifiLock;
public PTWifiAdministrator(Context context)
{
wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
wifiInfo = wifiManager.getConnectionInfo();
}

//获取wifi状态
public int GetWifiState()
{
return wifiManager.getWifiState();
}

public void CreateWifiLock()
{
wifiLock = wifiManager.createWifiLock("PTWifiLock");
}
public void AcquireWifiLock()
{
wifiLock.acquire();
}
public List<WifiConfiguration> GetWifiConfiguration()
{
return wifiConfigurationList;
}
public boolean ConnectConfiguration(int index)
{
if(wifiConfigurationList==null||index>wifiConfigurationList.size())
{
return false;
}else{
return wifiManager.enableNetwork(wifiConfigurationList.get(index).networkId, true);
}
}
//开始扫描周为wifi或者热点
public void StartScanWifi()
{
wifiManager.startScan();
scanResultList = wifiManager.getScanResults();
wifiConfigurationList = wifiManager.getConfiguredNetworks();
}
public List<ScanResult> GetScanResults()
{
return scanResultList;
}
//预览扫描到的wifi
public String LookUpScan()
{
StringBuffer sb = new StringBuffer();
for(int i=0;i<scanResultList.size();i++)
{
sb.append(i+":");
sb.append(scanResultList.get(i).SSID+";");
}
return sb.toString();
}
public String GetMacAdress()
{
return wifiInfo==null?null:wifiInfo.getMacAddress();
}
public String GetBSSID()
{
return wifiInfo==null?null:wifiInfo.getBSSID();
}
public int GetIPAdress()
{
return wifiInfo==null?null:wifiInfo.getIpAddress();
}
public int GetNetWordID()
{
return wifiInfo==null?null:wifiInfo.getNetworkId();
}
public String GetWifiInfo()
{
return wifiInfo==null?null:wifiInfo.toString();
}

public void DisConnectWifi(int netId)
{
wifiManager.disableNetwork(netId);
wifiManager.disconnect();
}
//打开wifi
public boolean OpenWifi()
{
if(!wifiManager.isWifiEnabled())
{
return wifiManager.setWifiEnabled(true);
}else{
return true;
}
}
//关闭wifi
public boolean CloseWifi()
{
if(wifiManager.isWifiEnabled())
{
return wifiManager.setWifiEnabled(false);
}
return false;
}
//连接wifi 根据ssid和password
public boolean Connect(String SSID, String Password, PTWifiConnect.WifiCipherType Type)
{
if(!this.OpenWifi())
{
return false;
}
while (wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING) {
try {
// Ϊ�˱��һֱwhileѭ��˯��100��ڼ�⡭��
Thread.currentThread();
Thread.sleep(100);
} catch (InterruptedException ie) {
}
}
WifiConfiguration wifiConfig = CreateWifiConfiguration(SSID, Password, Type);
if(wifiConfig==null)
{
return false;
}
WifiConfiguration tempConfig = this.IsExist(SSID);
if(tempConfig!=null)
{
wifiManager.removeNetwork(tempConfig.networkId);
}
int netId = wifiManager.addNetwork(wifiConfig);
wifiManager.disconnect();
boolean bRet = wifiManager.enableNetwork(netId, true);
wifiManager.reconnect();
return bRet;
}
//判断当前连接是否和该wifi匹配
public boolean IsConnect(ScanResult result)
{
if(result==null)
return false;
wifiInfo = wifiManager.getConnectionInfo();
String gc = "\""+result.SSID+"\"";
if(wifiInfo!=null&&wifiInfo.getSSID().endsWith(gc))
{
return true;
}else{
return false;
}
}
private WifiConfiguration IsExist(String SSID)
{
List<WifiConfiguration> existingConfigs = wifiManager.getConfiguredNetworks();

for(WifiConfiguration temp:existingConfigs)
{
if(temp.SSID.equals("\""+SSID+"\""))
{
return temp;
}
}
return null;
}
//生成WifiConfiguration对象给连接wifi用
private WifiConfiguration CreateWifiConfiguration(String SSID, String Password,PTWifiConnect.WifiCipherType Type)
{
WifiConfiguration wifiConfiguration = new WifiConfiguration();
wifiConfiguration.allowedAuthAlgorithms.clear();
wifiConfiguration.allowedGroupCiphers.clear();
wifiConfiguration.allowedKeyManagement.clear();
wifiConfiguration.allowedPairwiseCiphers.clear();
wifiConfiguration.allowedProtocols.clear();
wifiConfiguration.SSID = "\""+SSID+"\"";
if(Type==WifiCipherType.WIFICIPHER_NOPASS)
{
wifiConfiguration.wepKeys[0] = "";
wifiConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
wifiConfiguration.wepTxKeyIndex = 0;
}else if(Type==WifiCipherType.WIFICIPHER_WEP){
wifiConfiguration.preSharedKey = "\"" + Password + "\"";
wifiConfiguration.hiddenSSID = true;
wifiConfiguration.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
wifiConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
wifiConfiguration.wepTxKeyIndex = 0;
}else if(Type==WifiCipherType.WIFICIPHER_WPA)
{
wifiConfiguration.preSharedKey = "\"" + Password + "\"";
wifiConfiguration.hiddenSSID = true;
wifiConfiguration.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
wifiConfiguration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
wifiConfiguration.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
// config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
wifiConfiguration.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
wifiConfiguration.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
}else{
return null;
}
return wifiConfiguration;
}
public String ipIntToString(int ip) {
try {
byte[] bytes = new byte[4];
bytes[0] = (byte) (0xff & ip);
bytes[1] = (byte) ((0xff00 & ip) >> 8);
bytes[2] = (byte) ((0xff0000 & ip) >> 16);
bytes[3] = (byte) ((0xff000000 & ip) >> 24);
return Inet4Address.getByAddress(bytes).getHostAddress();
} catch (Exception e) {
return "";
}
}
public int getConnNetId() {
// result.SSID;
wifiInfo = wifiManager.getConnectionInfo();
return wifiInfo.getNetworkId();
}
public boolean connectSpecificAP(ScanResult scan) {
List<WifiConfiguration> list = wifiManager.getConfiguredNetworks();
boolean networkInSupplicant = false;
boolean connectResult = false;
// ��ָ��AP
wifiManager.disconnect();
for (WifiConfiguration w : list) {
// ��ָ��AP ��ת��
// String str = convertToQuotedString(info.ssid);
if (w.BSSID != null && w.BSSID.equals(scan.BSSID)) {
connectResult = wifiManager.enableNetwork(w.networkId, true);
// mWifiManager.saveConfiguration();
networkInSupplicant = true;
break;
}
}
if (!networkInSupplicant) {
WifiConfiguration config = CreateWifiInfo(scan, "youxiaohui");
connectResult = addNetwork(config);
}
return connectResult;
}
public boolean addNetwork(WifiConfiguration wcg) {
if (wcg == null) {
return false;
}
//receiverDhcp = new ReceiverDhcp(ctx, mWifiManager, this, wlanHandler);
//ctx.registerReceiver(receiverDhcp, new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION));
int wcgID = wifiManager.addNetwork(wcg);
boolean b = wifiManager.enableNetwork(wcgID, true);
wifiManager.saveConfiguration();
System.out.println(b);
return b;
}
public WifiConfiguration CreateWifiInfo(ScanResult scan, String Password) {
// Password="ultrapower2013";
// deleteExsits(info.ssid);
WifiConfiguration config = new WifiConfiguration();
config.hiddenSSID = false;
config.status = WifiConfiguration.Status.ENABLED;
if (scan.capabilities.contains("WEP")) {
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.OPEN);
config.allowedGroupCiphers
.set(WifiConfiguration.GroupCipher.WEP104);
config.SSID = "\"" + scan.SSID + "\"";
config.wepTxKeyIndex = 0;
config.wepKeys[0] = Password;
// config.preSharedKey = "\"" + SHARED_KEY + "\"";
} else if (scan.capabilities.contains("PSK")) {
//
config.SSID = "\"" + scan.SSID + "\"";
config.preSharedKey = "\"" + Password + "\"";
} else if (scan.capabilities.contains("EAP")) {
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
config.allowedAuthAlgorithms
.set(WifiConfiguration.AuthAlgorithm.OPEN);
config.allowedPairwiseCiphers
.set(WifiConfiguration.PairwiseCipher.TKIP);
config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
config.SSID = "\"" + scan.SSID + "\"";
config.preSharedKey = "\"" + Password + "\"";
} else {
config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
config.SSID = "\"" + scan.SSID + "\"";
// config.BSSID = info.mac;
config.preSharedKey = null;
//
}
return config;
}
}

3：MainActivity(这个activity主要是给unity交互用的，如果你懂android开发，换成自己的activity就行，把这个类的方法考进去就行)

package com.yxh.wifi;;

import com.unity3d.player.UnityPlayer;
import com.unity3d.player.UnityPlayerActivity;

import android.net.wifi.ScanResult;
import android.os.Bundle;

public class MainActivity extends UnityPlayerActivity {

public PTWifiAdministrator ptWifiAdministrator;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ptWifiAdministrator = new PTWifiAdministrator(this);
}

//打开wifi
public void OpenWifi()
{
ptWifiAdministrator.OpenWifi();
}
//获取wwifi状态
public boolean GetWifiState()
{
int state_id = ptWifiAdministrator.GetWifiState();
UnityPlayer.UnitySendMessage("PTUnityWifiObject","PTUnityWifiReceive","state:"+state_id);
return state_id==3;

}
ScanResult scanResult;
//连接wifi
public void ConnetWifi(int number)
{
scanResult = ptWifiAdministrator.GetScanResults().get(number);
ptWifiAdministrator.connectSpecificAP(scanResult);
}
//是否连接成功
public boolean IsConnect()
{
boolean b = ptWifiAdministrator.IsConnect(scanResult);
if(b)scanResult = null;
return b;
}
//扫描
public void WifiInit()
{
if(ptWifiAdministrator==null)
ptWifiAdministrator = new PTWifiAdministrator(this);
//UnityPlayer.UnitySendMessage("PTUnityWifiObject","PTUnityWifiReceive","1:lxl;2:yxh");

ptWifiAdministrator.StartScanWifi();
String ScanList = ptWifiAdministrator.LookUpScan();

UnityPlayer.UnitySendMessage("PTUnityWifiObject","PTUnityWifiReceive",ScanList);
}

}

4:androidManifest.xml在unity中这样配置

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.yxh.wifi"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk
android:minSdkVersion="8"
android:targetSdkVersion="21" />

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

<uses-permission android:name="android.permission.INTERNET" />
<application
android:allowBackup="true"
android:icon="@drawable/app_icon"
android:label="@string/app_name"
>
<activity
android:name=".MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>

</manifest>

5：unity这边与android交互的类PTUnityWifiObject

using UnityEngine;
using System.Collections;

public class PTUnityWifiObject : MonoBehaviour {

public static PTUnityWifiObject instance;

#if UNITY_ANDROID
private AndroidJavaClass aJC;
private AndroidJavaObject aJO;
#endif

// Use this for initialization
void Start () {
instance = this;

}
public void OpenWifi()
{
#if UNITY_ANDROID
if (aJO == null)
{
aJC = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
aJO = aJC.GetStatic<AndroidJavaObject>("currentActivity");
}

if (aJO != null)
{
PTWifi.tempT += "OpenWifi";
aJO.Call("OpenWifi");
StartCoroutine(GetOpenIsOk());
}
#endif
}
IEnumerator GetOpenIsOk()
{
yield return new WaitForSeconds(1f);
#if UNITY_ANDROID
if (aJO.Call<bool>("GetWifiState"))
{
//wifi开启成功
SearchWifi();
}
else
{
StartCoroutine(GetOpenIsOk());
}
#endif
}

public void SearchWifi()
{
#if UNITY_ANDROID
if (aJO == null)
{
aJC = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
aJO = aJC.GetStatic<AndroidJavaObject>("currentActivity");
}

#endif

#if UNITY_ANDROID
if (aJO != null)
{
aJO.Call("WifiInit");

}
#endif
}
//连接wifi
public void ConnectWifi(int number)
{
#if UNITY_ANDROID
if (aJO != null)
{
aJO.Call("ConnetWifi",new object[] { number });
}
#endif
StartCoroutine(WaitConnect());
}
IEnumerator WaitConnect()
{
yield return new WaitForSeconds(0.5f);
#if UNITY_ANDROID
if (aJO != null)
{
if (aJO.Call<bool>("IsConnect"))
{
if(PTWifi.instance!=null&& PTWifi.instance.currentPTWifiPaigoItem!=null)
PTWifi.instance.currentPTWifiPaigoItem.SetConnect();
}
else
{
StartCoroutine(WaitConnect());
}

}
#endif
}

// Update is called once per frame
void Update () {

}
void OnDestory()
{
instance = null;
}

public void PTUnityWifiReceive(string str)
{
if (PTWifi.instance != null)
{
PTWifi.instance.ShowWifi(str);
}
}

}

此项目本人已经跑通了，借鉴了很多别人的知识点，如有已经可以留言，多多交流。

1 0