Qt for android 之wifi 扫描 连接 断开
1.运行效果
android 端代码
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.text.TextUtils;
import android.util.Log;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.qtproject.example.ConverFromGBKToUTF8;
public class BaseWiFiManager {
private static final String TAG = "jason";
static WifiManager mWifiManager;
private List<WifiBean> mNewWifiLists =new ArrayList<>();
private static ConnectivityManager mConnectivityManager;
BaseWiFiManager(Context context) {
// 取得WifiManager对象
mWifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
if (mWifiManager == null) {
throw new RuntimeException("WifiManager is not supposed to be null");
}
mConnectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
}
/**
* 添加开放网络配置
*
* @param ssid SSID
* @return NetworkId
*/
int setOpenNetwork(String ssid) {
if (TextUtils.isEmpty(ssid)) {
return -1;
}
WifiConfiguration wifiConfiguration = getConfigFromConfiguredNetworksBySsid(ssid);
if (null == wifiConfiguration) {
// 生成配置
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.SSID = addDoubleQuotation(ssid);
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
wifiConfig.allowedAuthAlgorithms.clear();
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
// 添加配置并返回NetworkID
return addNetwork(wifiConfig);
} else {
// 返回NetworkID
return wifiConfiguration.networkId;
}
}
/**
* 添加WEP网络配置
*
* @param ssid SSID
* @param password 密码
* @return NetworkId
*/
int setWEPNetwork(String ssid, String password) {
if (TextUtils.isEmpty(ssid) || TextUtils.isEmpty(password)) {
return -1;
}
WifiConfiguration wifiConfiguration = getConfigFromConfiguredNetworksBySsid(ssid);
if (null == wifiConfiguration) {
// 添加配置
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.SSID = addDoubleQuotation(ssid);
wifiConfig.wepKeys[0] = "\"" + password + "\"";
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
wifiConfig.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
// 添加配置并返回NetworkID
return addNetwork(wifiConfig);
} else {
// 更新配置并返回NetworkID
wifiConfiguration.wepKeys[0] = "\"" + password + "\"";
return updateNetwork(wifiConfiguration);
}
}
/**
* 添加WPA网络配置
*
* @param ssid SSID
* @param password 密码
* @return NetworkId
*/
int setWPA2Network( String ssid, String password) {
if (TextUtils.isEmpty(ssid) || TextUtils.isEmpty(password)) {
return -1;
}
WifiConfiguration wifiConfiguration = getConfigFromConfiguredNetworksBySsid(ssid);
if (null == wifiConfiguration) {
WifiConfiguration wifiConfig = new WifiConfiguration();
wifiConfig.SSID = addDoubleQuotation(ssid);
wifiConfig.preSharedKey = "\"" + password + "\"";
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
wifiConfig.status = WifiConfiguration.Status.ENABLED;
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
wifiConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
wifiConfig.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
wifiConfig.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
// 添加配置并返回NetworkID
return addNetwork(wifiConfig);
} else {
// 更新配置并返回NetworkID
wifiConfiguration.preSharedKey = "\"" + password + "\"";
return updateNetwork(wifiConfiguration);
}
}
/**
* 通过热点名获取热点配置
*
* @param ssid 热点名
* @return 配置信息
*/
public WifiConfiguration getConfigFromConfiguredNetworksBySsid( String ssid) {
ssid = addDoubleQuotation(ssid);
List<WifiConfiguration> existingConfigs = getConfiguredNetworks();
if (null != existingConfigs) {
for (WifiConfiguration existingConfig : existingConfigs) {
Log.e(TAG, " 获取配置过的WIFI信息--通过热点名获取热点配置---"+existingConfig);//几秒回调一次
if (existingConfig.SSID.equals(ssid)) {
return existingConfig;
}
}
}
return null;
}
/**
* 获取WIFI的开关状态
*
* @return WIFI的可用状态
*/
public boolean isWifiEnabled() {
return null != mWifiManager && mWifiManager.isWifiEnabled();
}
/**
* 判断WIFI是否连接
*
* @return 是否连接
*/
boolean isWifiConnected() {
if (null != mConnectivityManager) {
NetworkInfo networkInfo = mConnectivityManager.getActiveNetworkInfo();
return null != networkInfo && networkInfo.isConnected() && networkInfo.getType() == ConnectivityManager.TYPE_WIFI;
}
return false;
}
/**
* 判断设备是否有网
*
* @return 网络状态
*/
boolean hasNetwork() {
if (null != mConnectivityManager) {
NetworkInfo networkInfo = mConnectivityManager.getActiveNetworkInfo();
return networkInfo != null && networkInfo.isAvailable();
}
return false;
}
/**
* 获取当前正在连接的WIFI信息
*
* @return 当前正在连接的WIFI信息
*/
public WifiInfo getConnectionInfo() {
if (null != mWifiManager) {
return mWifiManager.getConnectionInfo();
}
return null;
}
/**
* 扫描附近的WIFI
*/
public void startScan() {
if (null != mWifiManager) {
mWifiManager.startScan();
}
}
/**
* 获取最近扫描的WIFI热点
*
* @return WIFI热点列表
*/
public List<ScanResult> getScanResults() {
// 得到扫描结果
if (null != mWifiManager) {
return mWifiManager.getScanResults();
}
return null;
}
/**
* 排除重复
*
* @param scanResults 带处理的数据
* @return 去重数据
*/
public static ArrayList<ScanResult> excludeRepetition(List<ScanResult> scanResults) {
HashMap<String, ScanResult> hashMap = new HashMap<>();
for (ScanResult scanResult : scanResults) {
String ssid = scanResult.SSID;
if (TextUtils.isEmpty(ssid)) {
continue;
}
ScanResult tempResult = hashMap.get(ssid);
if (null == tempResult) {
hashMap.put(ssid, scanResult);
continue;
}
if (WifiManager.calculateSignalLevel(tempResult.level, 100) < WifiManager.calculateSignalLevel(scanResult.level, 100)) {
hashMap.put(ssid, scanResult);
}
}
ArrayList<ScanResult> results = new ArrayList<>();
for (Map.Entry<String, ScanResult> entry : hashMap.entrySet()) {
results.add(entry.getValue());
}
return results;
}
/**
* 获取配置过的WIFI信息
*
* @return 配置信息
*/
private List<WifiConfiguration> getConfiguredNetworks() {
if (null != mWifiManager) {
return mWifiManager.getConfiguredNetworks();
}
return null;
}
/**
* 保持配置
*
* @return 保持是否成功
*/
boolean saveConfiguration() {
return null != mWifiManager && mWifiManager.saveConfiguration();
}
/**
* 连接到网络
*
* @param networkId NetworkId
* @return 连接结果
*/
boolean enableNetwork(int networkId) {
if (null != mWifiManager) {
boolean isDisconnect = disconnectCurrentWifi();
boolean isEnableNetwork = mWifiManager.enableNetwork(networkId, true);
boolean isSave = mWifiManager.saveConfiguration();
boolean isReconnect = mWifiManager.reconnect();
return isDisconnect && isEnableNetwork && isSave && isReconnect;
}
return false;
}
/**
* 添加网络配置
*
* @param wifiConfig 配置信息
* @return NetworkId
*/
private int addNetwork(WifiConfiguration wifiConfig) {
if (null != mWifiManager) {
int networkId = mWifiManager.addNetwork(wifiConfig);
if (-1 != networkId) {
boolean isSave = mWifiManager.saveConfiguration();
if (isSave) {
return networkId;
}
}
}
return -1;
}
/**
* 更新网络配置
*
* @param wifiConfig 配置信息
* @return NetworkId
*/
private int updateNetwork(WifiConfiguration wifiConfig) {
if (null != mWifiManager) {
int networkId = mWifiManager.updateNetwork(wifiConfig);
if (-1 != networkId) {
boolean isSave = mWifiManager.saveConfiguration();
if (isSave) {
return networkId;
}
}
}
return -1;
}
/**
* 断开指定 WIFI
*
* @param netId netId
* @return 是否断开
*/
public boolean disconnectWifi(int netId) {
if (null != mWifiManager) {
//禁用网络
boolean isDisable = mWifiManager.disableNetwork(netId);
boolean isDisconnect = mWifiManager.disconnect();
return isDisable && isDisconnect;
}
return false;
}
public static boolean disconnectFromWifi() {
boolean discont = false;
if(null!=mWifiManager) {
discont = mWifiManager.disconnect();
}
return discont;
}
/**
* 断开当前的WIFI
*
* @return 是否断开成功
*/
public boolean disconnectCurrentWifi() {
WifiInfo wifiInfo = getConnectionInfo();
if (null != wifiInfo) {
int networkId = wifiInfo.getNetworkId();
return disconnectWifi(networkId);
} else {
// 断开状态
return true;
}
}
/**
* 删除配置----------------->取消保存操作
*
* @param netId netId
* @return 是否删除成功
*/
public boolean deleteConfig(int netId) {
if (null != mWifiManager) {
boolean isDisable = mWifiManager.disableNetwork(netId);
boolean isRemove = mWifiManager.removeNetwork(netId);
boolean isSave = mWifiManager.saveConfiguration();
return isDisable && isRemove && isSave;
}
return false;
}
/**
* 计算WIFI信号强度
*
* @param rssi WIFI信号
* @return 强度
*/
public int calculateSignalLevel(int rssi) {
return WifiManager.calculateSignalLevel(rssi, 5);
}
/**
* 获取WIFI的加密方式
*
* @param scanResult WIFI信息
* @return 加密方式
*/
public SecurityModeEnum getSecurityModeStr(String capabilities) {
if (capabilities.contains("WPA")||capabilities.contains("WPA-PSK")|| capabilities.contains("WPA2") || capabilities.contains("WPA2-PSK")|| capabilities.contains("WPS")) {
return SecurityModeEnum.WPA;
} else if (capabilities.contains("WEP")) {
return SecurityModeEnum.WEP;
// } else if (capabilities.contains("EAP")) {
// return SecurityMode.WEP;
} else {
// 没有加密
return SecurityModeEnum.OPEN;
}
}
/**
* 添加双引号
*
* @param text 待处理字符串
* @return 处理后字符串
*/
public String addDoubleQuotation(String text) {
if (TextUtils.isEmpty(text)) {
return "";
}
return "\"" + text + "\"";
}
//=====================新增如下：===============================
/**
* 得到当前连接的WiFi SSID
*
* @return
*/
public String getCurrentWifiSSID() {
String ssid = mWifiManager.getConnectionInfo().getSSID();
if (ssid.substring(0, 1).equals("\"")
&& ssid.substring(ssid.length() - 1).equals("\"")) {
ssid = ssid.substring(1, ssid.length() - 1);
}
return trimSSID(ssid);
}
/**
* 获取到的wifi名称前后可能带有引号
*
* @param ssid
* @return
*/
public String trimSSID(String ssid) {
if (ssid.substring(0, 1).equals("\"")
&& ssid.substring(ssid.length() - 1).equals("\"")) {
ssid = ssid.substring(1, ssid.length() - 1);
}
return ssid;
}
/**
* 获取WIFI的加密方式
* 安全模式：WPA WPA2
*
* @return 加密方式
*/
public SecurityModeEnum getSecurityMode( WifiBean bean) {
String capabilities = bean.getCapabilities();
if (capabilities.contains("WPA")||capabilities.contains("WPA-PSK")|| capabilities.contains("WPA2") || capabilities.contains("WPA2-PSK")|| capabilities.contains("WPS")) {
return SecurityModeEnum.WPA;
} else if (capabilities.contains("WEP")) {
return SecurityModeEnum.WEP;
// } else if (capabilities.contains("EAP")) {
// return SecurityMode.WEP;
} else {
// 没有加密
return SecurityModeEnum.OPEN;
}
}
/**
* 过滤扫描wifi名称为空的数据
* @param scanResults
* @return
*/
public List<WifiBean> filterWifiNameIsEmpty(List<ScanResult> scanResults) {
ArrayList<ScanResult> scanNewResults = excludeRepetition(scanResults);
mNewWifiLists.clear();
if (!CollectionUtils.isNullOrEmpty(scanNewResults)) {
for (int i = 0; i < scanNewResults.size(); i++) {
ScanResult scanResult = scanNewResults.get(i);
WifiBean wifiBean = new WifiBean();
wifiBean.setWifiName(ConverFromGBKToUTF8.unicodeToUtf8(scanResult.SSID));
// wifiBean.setWifiName(ConverFromGBKToUTF8.getUTF8StringFromGBKString(scanResult.SSID));
wifiBean.setMacAddress(scanResult.BSSID);
wifiBean.setLevel(String.valueOf(scanResult.level));
wifiBean.setState(AppConstants.WIFI_STATE_UNCONNECT); //只要获取都假设设置成未连接，真正的状态都通过广播来确定
wifiBean.setCapabilities(scanResult.capabilities);
wifiBean.setScanResult(scanResult);
mNewWifiLists.add(wifiBean);
}
}
return mNewWifiLists;
}
/**
* 连接wifi时状态发生变化
* @param wifiName 连接wifi ssid
* @param type 0 未连接 1 连接成功 2正在连接中
* @return
*/
public List<WifiBean> changeStateWhenWifiIsConnected(String wifiName, int type) {
// Log.e(TAG, "wifi 列表发生设置新数据 -----");//几秒回调一次
int index = -1;
WifiBean wifiInfo = new WifiBean();
if(mNewWifiLists!=null && mNewWifiLists.size()>0){
Collections.sort(mNewWifiLists);//根据信号强度排序
for (int i = 0; i < mNewWifiLists.size(); i++) {
WifiBean wifiBean = mNewWifiLists.get(i);
if (index == -1 && ("\"" + wifiBean.getWifiName() + "\"").equals(wifiName)) {
index = i;
wifiInfo.setWifiName(wifiBean.getWifiName());
wifiInfo.setMacAddress(wifiBean.getMacAddress());
wifiInfo.setLevel(wifiBean.getLevel());
if (type == 1) {//已经连接
wifiInfo.setState(AppConstants.WIFI_STATE_CONNECT);
} else if (type == 2){//正在连接
wifiInfo.setState(AppConstants.WIFI_STATE_ON_CONNECTING);
}else {
wifiInfo.setState(AppConstants.WIFI_STATE_UNCONNECT);
}
wifiInfo.setCapabilities(wifiBean.getCapabilities());
wifiInfo.setScanResult(wifiBean.getScanResult());
}
}
if (index != -1) {
mNewWifiLists.remove(index);
mNewWifiLists.add(0, wifiInfo);
}
}
return mNewWifiLists;
}
/**
之前已经连接未曾断开wifi数据
*/
public List<WifiBean> alreadyConnectedAndNeverDisconnectedWifiData(List<ScanResult> scanResults,String wifiName) {
int index = -1;
ArrayList<ScanResult> scanNewResults =excludeRepetition(scanResults);
if (!CollectionUtils.isNullOrEmpty(scanNewResults)) {
mNewWifiLists.clear();
for (int i = 0; i < scanNewResults.size(); i++) {
ScanResult scanResult = scanNewResults.get(i);
WifiBean wifiBean = new WifiBean();
wifiBean.setWifiName(ConverFromGBKToUTF8.unicodeToUtf8(scanResult.SSID));
//wifiBean.setWifiName(ConverFromGBKToUTF8.getUTF8StringFromGBKString(scanResult.SSID));
wifiBean.setMacAddress(scanResult.BSSID);
wifiBean.setLevel(String.valueOf(scanResult.level));
if (scanResult.SSID.equals(wifiName)) {
index =i;
wifiBean.setState(AppConstants.WIFI_STATE_CONNECT);
}else{
wifiBean.setState(AppConstants.WIFI_STATE_UNCONNECT);
}
wifiBean.setCapabilities(scanResult.capabilities);
wifiBean.setScanResult(scanResult);
mNewWifiLists.add(wifiBean);
}
// Log.e("jason","index===="+index);
if (index != -1) {
if(mNewWifiLists!=null){
List<WifiBean> arrlist=new ArrayList<WifiBean>();
for (int j = 0; j < mNewWifiLists.size(); j++) {
if(index ==j){
arrlist.add(0,mNewWifiLists.get(j));
}else{
arrlist.add(mNewWifiLists.get(j));
}
}
mNewWifiLists.clear();
mNewWifiLists.addAll(arrlist);
}
}
}
return mNewWifiLists;
}
//=====================================================
}
WiFiManager.java
public class WiFiManager extends BaseWiFiManager {
private static final String TAG = "jason";
private static WiFiManager mWiFiManager;
private WiFiManager(Context context) {
super(context);
}
public static WiFiManager getInstance(Context context) {
if (null == mWiFiManager) {
synchronized (WiFiManager.class) {
if (null == mWiFiManager) {
mWiFiManager = new WiFiManager(context);
}
}
}
return mWiFiManager;
}
/**
* 打开Wifi
*/
public void openWiFi() {
if (!isWifiEnabled() && null != mWifiManager) {
mWifiManager.setWifiEnabled(true);
}
}
/**
* 关闭Wifi
*/
public void closeWiFi() {
if (isWifiEnabled() && null != mWifiManager) {
mWifiManager.setWifiEnabled(false);
}
}
/**
* 连接到开放网络
*
* @param ssid 热点名
* @return 配置是否成功
*/
public boolean connectOpenNetwork( String ssid) {
// 获取networkId
int networkId = setOpenNetwork(ssid);
if (-1 != networkId) {
// 保存配置
boolean isSave = saveConfiguration();
// 连接网络
boolean isEnable = enableNetwork(networkId);
return isSave && isEnable;
}
return false;
}
/**
* 连接到WEP网络
*
* @param ssid 热点名
* @param password 密码
* @return 配置是否成功
*/
public boolean connectWEPNetwork( String ssid, String password) {
// 获取networkId
int networkId = setWEPNetwork(ssid, password);
if (-1 != networkId) {
// 保存配置
boolean isSave = saveConfiguration();
// 连接网络
boolean isEnable = enableNetwork(networkId);
return isSave && isEnable;
}
return false;
}
public static class NetworkBroadcastReceiver extends BroadcastReceiver {
private static final String TAG = "jason";
@SuppressLint({"MissingPermission", "LongLogTag"})
@Override
public void onReceive(Context context, Intent intent) {
// Log.e("jason", "onReceive: 开始执行======================");
WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
switch (intent.getAction()) {
case WifiManager.WIFI_STATE_CHANGED_ACTION: // WIFI状态发生变化
/**
* WifiManager.WIFI_STATE_CHANGED_ACTION
* 解释： WIFI 开关（是否可用）状态广播
* 状态相关类： WifiManager
*
* 状态如下：
*
* WIFI_STATE_DISABLED： WIFI功能已经被关闭
* WIFI_STATE_DISABLING： WIFI功能关闭中，处于此状态WIFI不可以用
* WIFI_STATE_ENABLED： WIFI功能已经被打开
* WIFI_STATE_ENABLING： WIFI功能正在打开中，处于此状态WIFI可用
* WIFI_STATE_UNKNOWN： WIFI功能状态不可知
*
*/
switch (intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN)) {
case WifiManager.WIFI_STATE_ENABLING:
// Log.e(TAG, "onReceive: 正在打开 WIFI...");
break;
case WifiManager.WIFI_STATE_ENABLED:
// Log.e(TAG, "onReceive: WIFI 已打开");
if (null != mOnWifiEnabledListener) {
mOnWifiEnabledListener.onWifiEnabled(true);
// mCallBackHandler.sendEmptyMessage(WIFI_STATE_ENABLED);
}
break;
case WifiManager.WIFI_STATE_DISABLING:
// Log.e(TAG, "onReceive: 正在关闭 WIFI...");
break;
case WifiManager.WIFI_STATE_DISABLED:
// Log.e(TAG, "onReceive: WIFI 已关闭");
if (null != mOnWifiEnabledListener) {
mOnWifiEnabledListener.onWifiEnabled(false);
}
break;
case WifiManager.WIFI_STATE_UNKNOWN:
default:
// Log.e(TAG, "onReceive: WIFI 状态未知!");
break;
}
break;
case WifiManager.SCAN_RESULTS_AVAILABLE_ACTION: // WIFI扫描完成
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
boolean isUpdated = intent.getBooleanExtra(WifiManager.EXTRA_RESULTS_UPDATED, false);
// Log.e("AA", "onReceive: WIFI扫描 " + (isUpdated ? "完成" : "未完成"));
} else {
// Log.e("AA", "onReceive: WIFI扫描完成");
}
if (null != mOnWifiScanResultsListener) {
mOnWifiScanResultsListener.onScanResults(wifiManager.getScanResults());
}
break;
case WifiManager.NETWORK_STATE_CHANGED_ACTION: // 网络状态变化广播
/**
* WifiManager.NETWORK_STATE_CHANGED_ACTION
* 解释： 网络状态变化广播
* 状态相关类： NetworkInfo
*
* 1）通用状态（State）：
*
* CONNECTING： 正在连接网络；
* CONNECTED： 网络连接成功；
* SUSPENDED： 网络暂停；
* DISCONNECTING： 正在断开连接；
* DISCONNECTED： 连接已断开；
* UNKNOWN: 未知状态；
* 2）详细状态（DetailedState）：
*
* IDLE： 准备开始数据连接设置；
* SCANNING：正在搜索可用网络；
* CONNECTING： 正在建立数据连接；
* AUTHENTICATING： 网络连接建立，执行身份认证；
* OBTAINING_IPADDR： 等待DHCP服务器的相应以分配IP地址信息；
* CONNECTED： 此时IP流量应该是可用的；
* SUSPENDED： IP流量暂停
* DISCONNECTING： 当前正在断开数据连接；
* DISCONNECTED： 网络连接已断开，IP流量不可用；
* FAILED：尝试连接失败；
* BLOCKED： 禁止访问此网络；
* VERIFYING_POOR_LINK： 链接连接不良；
* CAPTIVE_PORTAL_CHECK: 检查网络是否是强制网络门户；
*
*/
// Log.e(TAG, "onReceive: WIFI连接状态发生改变");
// NetworkInfo networkInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
// if (null != networkInfo && ConnectivityManager.TYPE_WIFI == networkInfo.getType()) {
// }
NetworkInfo networkInfo = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
if(networkInfo.getState()==NetworkInfo.State.CONNECTING ){//正在连接网络；
// Log.e(TAG, "onReceive: 正在连接网络" );
// WifiInfo connectingInfo = wifiManager.getConnectionInfo();
// if (null != mOnWifiScanResultsListener) {
// Log.e(TAG, " SUPPLICANT_STATE_CHANGED_ACTION 获取连接状态{" + connectingInfo.toString());
//
// Log.e(TAG, "onWifiIsConnecting 正在连接中---------------------------------");
// mOnWifiConnectListener.onWifiIsConnecting(connectingInfo.getSSID(),2);
// }
}else if(networkInfo.getState()==NetworkInfo.State.DISCONNECTED ){//连接已断开
// Log.e(TAG, "onReceive: 连接已断开" );
}else if(networkInfo.getState()==NetworkInfo.State.CONNECTED ){// 网络连接成功
// Log.e(TAG, "onReceive: 网络连接成功" );
}
WifiInfo wifiInfo = intent.getParcelableExtra(WifiManager.EXTRA_WIFI_INFO);
if (null != wifiInfo && wifiInfo.getSupplicantState() == SupplicantState.COMPLETED) {
String ssid = wifiInfo.getSSID();
// Log.e(TAG, "onReceive: 网络连接成功 ssid = " + ssid);
if (null != mOnWifiConnectListener) {
mOnWifiConnectListener.onWiFiConnectSuccess(ssid,1);
// Log.e(TAG, "onWiFiConnectSuccess wifi 已经连接成功---------------------------------");
}
}
break;
case WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION:
boolean isConnected = intent.getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false);
// Log.e(TAG, "onReceive: SUPPLICANT_CONNECTION_CHANGE_ACTION isConnected = " + isConnected);
break;
case WifiManager.SUPPLICANT_STATE_CHANGED_ACTION: // WIFI连接请求状态发生改变
/** WifiManager.SUPPLICANT_STATE_CHANGED_ACTION
* 解释： 建立与Access Point的连接状态变化广播
* 状态标注类： SupplicantState
*/
// 获取连接状态
SupplicantState supplicantState = intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE);
int supl_error = intent.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, -1);
WifiInfo connectionSupplicantState = wifiManager.getConnectionInfo();
if (null != mOnWifiScanResultsListener) {
// Log.e(TAG, " SUPPLICANT_STATE_CHANGED_ACTION 获取连接状态{" + supplicantState.toString());
//mOnWifiConnectListener.onWiFiConnectLog(supplicantState.toString());
mOnWifiConnectListener.onWifiIsConnecting(connectionSupplicantState.getSSID(),2);
}
switch (supplicantState) {
case INTERFACE_DISABLED: // 接口禁用
//INTERFACE_DISABLED： 禁用网络接口时进入此状态，wpa_supplication拒绝任何使用无线的操作；
// Log.e(TAG, "onReceive: INTERFACE_DISABLED 接口禁用");
break;
case DISCONNECTED:// 断开连接
//DISCONNECTED： 客户端未连接AP，但是正在搜索一个AP，如连接丢失时触发；
// Log.e(TAG, "onReceive: DISCONNECTED: 断开连接");
WifiInfo connectFailureInfo = wifiManager.getConnectionInfo();
if(supplicantState == SupplicantState.DISCONNECTED &&supl_error == WifiManager.ERROR_AUTHENTICATING){
if (null != mOnWifiScanResultsListener) {
if(AppConstants.isPasswordError==0) {
// Log.e(TAG, "onWiFiConnectAuthenticatingError 密码错误-if---isPasswordError"+AppConstants.isPasswordError);
mOnWifiConnectListener.onWiFiConnectAuthenticatingError(supl_error, connectionSupplicantState.getSSID(), 0);
AppConstants.isPasswordError= 1;
// Log.e(TAG, "onWiFiConnectAuthenticatingError 密码错误--------------------------------- " + AppConstants.isPasswordError);
List<WifiConfiguration> configuredNetworks = mWifiManager.getConfiguredNetworks();
if (null != configuredNetworks) {
for (WifiConfiguration existingConfig : configuredNetworks) {
if (existingConfig.SSID.equals(connectFailureInfo.getSSID())) {
boolean isDisable = mWifiManager.disableNetwork(existingConfig.networkId);
boolean isRemove = mWifiManager.removeNetwork(existingConfig.networkId);
boolean isSave = mWifiManager.saveConfiguration();
if(isDisable && isRemove && isSave){
AppConstants.isPasswordError=0;
// Log.e(TAG, "onWiFiConnectAuthenticatingError 密码错误--------------------保存的网络已经移除------------- " + AppConstants.isPasswordError);
}
}
}
}
}
}
}else {
if (null != connectFailureInfo) {
if (null != mOnWifiScanResultsListener) {
Log.e(TAG, "onWiFiConnectFailure 其它错误-if---isPasswordError" + AppConstants.isPasswordError);
mOnWifiConnectListener.onWiFiConnectFailure(connectionSupplicantState.getSSID(), 0);
//Log.e(TAG, "onWiFiConnectFailure 其它错误--------------------------------- " + AppConstants.isPasswordError);
}
}
}
break;
case INACTIVE: // 不活跃的
// INACTIVE WIFI配置中没有启用的网络时进入此状态，同时没有和任何网络尝试连接，需要外部交互来建立连接；
WifiInfo connectInactiveInfo = wifiManager.getConnectionInfo();
// Log.e(TAG, "onReceive: INACTIVE 不活跃的 connectFailureInfo = " + connectInactiveInfo);
if (null != connectInactiveInfo) {
if (null != mOnWifiScanResultsListener) {
mOnWifiConnectListener.onWiFiConnectFailure(connectInactiveInfo.getSSID(), 0);
}
// 断开连接
int networkId = connectInactiveInfo.getNetworkId();
boolean isDisable = wifiManager.disableNetwork(networkId);
boolean isDisconnect = wifiManager.disconnect();
// Log.e(TAG, "onReceive: 断开连接 = " + (isDisable && isDisconnect));
}
break;
case SCANNING: // 正在扫描
//SCANNING： 正在扫描网络；
// Log.e(TAG, "onReceive: SCANNING 正在扫描");
break;
case AUTHENTICATING: // 正在验证
//AUTHENTICATING： 发现合适网络,尝试与此网络进行认证时进入此状态，与网络驱动相关；
// Log.e(TAG, "onReceive: AUTHENTICATING: // 正在验证");
break;
case ASSOCIATING: // 正在关联
//ASSOCIATING： 尝试与SSID对应的AP进行关联，与网络驱动相关；
// Log.e(TAG, "onReceive: ASSOCIATING: // 正在关联");
break;
case ASSOCIATED: // 已经关联
//ASSOCIATED： 当网络驱动已经返回与AP的关联成功时进入此状态，如果使用的是IEEE 802.1X模式，
// 会等到起身份认证成功后进入此状态；
// Log.e(TAG, "onReceive: ASSOCIATED: // 已经关联");
break;
case FOUR_WAY_HANDSHAKE:
//FOUR_WAY_HANDSHAKE 当WPA/WPA2 四次握手启动时进入此状态，如果是WPA-PSK情况下，关联成功后接收到第一个EAPOL-Key帧时会直接进入此状态。在WPA-EAP的情况下，
// Log.e(TAG, "onReceive: FOUR_WAY_HANDSHAKE://四次握手");
break;
case GROUP_HANDSHAKE:
//GROUP_HANDSHAKE 四次握手完成，当请求者开始接收消失时，进入此状态；
// Log.e(TAG, "onReceive: GROUP_HANDSHAKE: //集体握手");
break;
case COMPLETED: // 完成
//COMPLETED 所有认证已经完成进入状态，此时可能没有分配任何IP，需要发送DHCP请求来获取地址；
// Log.e(TAG, "onReceive: WIFI_CONNECT_SUCCESS: wifi 已经连接成功// 完成");
// WifiInfo connectSuccessInfo = wifiManager.getConnectionInfo();
//
// if (null != connectSuccessInfo) {
// if (null != mOnWifiConnectListener) {
// mOnWifiConnectListener.onWiFiConnectSuccess(connectSuccessInfo.getSSID(),1);
// Log.e(TAG, "onReceive: WIFI_CONNECT_SUCCESS: wifi 已经连接成功// 完成");
// }
// }
break;
case DORMANT:
//DORMANT：用户明确发出中断指令时进入状态；
// Log.e(TAG, "onReceive: DORMANT:用户明确发出中断指令时进入状态；");
break;
case UNINITIALIZED: // 未初始化
//UNINITIALIZED： 没有连接wpa_supplicant，是一个伪状态；
// Log.e(TAG, "onReceive: UNINITIALIZED: // 未初始化");
break;
case INVALID: // 无效的
//INVALID: 伪状态，一般不会出现；
// Log.e(TAG, "onReceive: INVALID: // 无效的");
break;
default:
break;
}
break;
default:
break;
}
}
}
/**
* 连接到WPA2网络
*
* @param ssid 热点名
* @param password 密码
* @return 配置是否成功
*/
public boolean connectWPA2Network( String ssid, String password) {
// 获取networkId
int networkId = setWPA2Network(ssid, password);
if (-1 != networkId) {
// 保存配置
boolean isSave = saveConfiguration();
// 连接网络
boolean isEnable = enableNetwork(networkId);
return isSave && isEnable;
}
return false;
}
protected static OnWifiEnabledListener mOnWifiEnabledListener;//监听wifi 是否打开的回调
protected static OnWifiScanResultsListener mOnWifiScanResultsListener;//监听WiFi扫描的回调函数
protected static OnWifiConnectListener mOnWifiConnectListener;
public void setOnWifiEnabledListener(OnWifiEnabledListener listener) {
mOnWifiEnabledListener = listener;
}
public void removeOnWifiEnabledListener() {
mOnWifiEnabledListener = null;
}
public void setOnWifiScanResultsListener(OnWifiScanResultsListener listener) {
mOnWifiScanResultsListener = listener;
}
public void removeOnWifiScanResultsListener() {
mOnWifiScanResultsListener = null;
}
public void setOnWifiConnectListener(OnWifiConnectListener listener) {
mOnWifiConnectListener = listener;
}
public void removeOnWifiConnectListener() {
mOnWifiConnectListener = null;
}
}
事件回调处理接口
/**
* WIFI连接的回调接口
*/
public interface OnWifiConnectListener {
/**
* WIFI连接中的信息回调
* @param wifiName wifi名称
* @param connectionType 连接类型 0未连接 1连接成功 2正在连接
*/
void onWifiIsConnecting(String wifiName,int connectionType);
/**
* wifi 连接失败
* @param wifiName
* @param connectionType
*/
void onWiFiConnectFailure(String wifiName, int connectionType);
/**
* wifi 密码错误
* @param errorMsg 错误信息 1 密码错误
* @param wifiName wifi名称
* @param connectionType 连接类型 0未连接 1连接成功 2正在连接
*/
void onWiFiConnectAuthenticatingError(int errorMsg, String wifiName, int connectionType);
/**
* WIFI连接成功的回调
* @param wifiName wifi名称
* @param connectionType 连接类型 0未连接 1连接成功 2正在连接
*/
void onWiFiConnectSuccess(String wifiName, int connectionType);
}
/**
* Created by kqw on 2016/8/4.
* WIFI打开关闭的回调接口
*/
public interface OnWifiEnabledListener {
/**
* WIFI开关的回调
*
* @param enabled true 可用 false 不可用
*/
void onWifiEnabled(boolean enabled);
}
/**
*
* WIFI扫描结果的回调接口
*/
public interface OnWifiScanResultsListener {
/**
* 扫描结果的回调
*
* @param scanResults 扫描结果
*/
void onScanResults(List<ScanResult> scanResults);
}
WifiBean .java 封装wifi数据
import android.net.wifi.ScanResult;
import android.os.Parcel;
import android.os.Parcelable;
public class WifiBean implements Comparable<WifiBean>, Parcelable {
private static final long serialVersionUID = -7060210544600464481L;
private String wifiName;
private String macAddress;
private String level;
private String state; //已连接 正在连接 未连接 三种状态
private String capabilities;//加密方式
private ScanResult scanResult;//原生的对象ScanResult
public String getCapabilities() {
return capabilities;
}
public void setCapabilities(String capabilities) {
this.capabilities = capabilities;
}
public String getWifiName() {
return wifiName;
}
public void setWifiName(String wifiName) {
this.wifiName = wifiName;
}
public String getMacAddress() {
return macAddress;
}
public void setMacAddress(String macAddress) {
this.macAddress = macAddress;
}
public String getLevel() {
return level;
}
public void setLevel(String level) {
this.level = level;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
@Override
public int compareTo(WifiBean o) {
int level1 = Integer.parseInt(getLevel());
int level2 = Integer.parseInt(o.getLevel());
if (level1 > level2) {//降序
return -1;
} else if (level1 == level2) {
return 0;
} else {
return 1;
}
}
@Override
public String toString() {
// return "自定义WifiBean{" +
// "wifiName='" + wifiName + '\'' +
// ", state='" + state + '\'' +
// ", level='" + level + '\'' +
// ", capabilities='" + capabilities + '\'' +
// ",\n 扫描点scanResult=" + scanResult +
// '}';
return "自定义WifiBean{" +
"macAddress='" + macAddress + '\'' +
"wifiName='" + wifiName + '\'' +
", level='" + level + '\'' +
", state='" + state + '\'' +
", capabilities='" + capabilities + '\'' +
",\n 扫描点scanResult=" + scanResult +
'}';
}
public ScanResult getScanResult() {
return scanResult;
}
public void setScanResult(ScanResult scanResult) {
this.scanResult = scanResult;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(wifiName);
dest.writeString(macAddress);
dest.writeString(level);
dest.writeString(state);
dest.writeString(capabilities);
dest.writeValue(scanResult);
}
public static final Creator<WifiBean> CREATOR = new Creator<WifiBean>() {
@Override
public WifiBean createFromParcel(Parcel source) {
WifiBean model = new WifiBean();
model.wifiName = source.readString();
model.macAddress =source.readString();
model.level = source.readString();
model.state = source.readString();
model.capabilities = source.readString();
model.scanResult = (ScanResult) source.readValue(ScanResult.class.getClassLoader());
return model;
}
@Override
public WifiBean[] newArray(int size) {
return new WifiBean[size];
}
};
}
AppActivity.java 调用类
public class AppActivity extends org.qtproject.qt5.android.bindings.QtActivity implements OnWifiScanResultsListener, OnWifiConnectListener, OnWifiEnabledListener
{
public String registerCodeState ="";
private static final String TAG = "Jason";
//wifiBeans保存的是连接中状态变化数据
private List<WifiBean> wifiBeans;
//存放扫描到wifi列表数据
private List<WifiBean> mList =new ArrayList<>();;
private WiFiManager mWiFiManager;
private NativeTools mjniTools;
//wifi 初始化结束
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mjniTools = new NativeTools();
mWiFiManager = WiFiManager.getInstance(MyApplication.getContext());
// 添加监听
mWiFiManager.setOnWifiEnabledListener(this);
mWiFiManager.setOnWifiScanResultsListener(this);
mWiFiManager.setOnWifiConnectListener(this);
if(wifiBeans!=null ){
wifiBeans.clear();
}
if(mList!=null){
mList.clear();
}
}
//======================wifi 操作==========================================
/**
打开wifi
*/
public void openSystemWiFi(){
mWiFiManager.openWiFi();
}
/**
关闭wifi
*/
public void closeSystemWiFi(){
mWiFiManager.closeWiFi();
if(wifiBeans!=null ){
wifiBeans.clear();
}
if(mList!=null){
mList.clear();
}
}
/**
通过定位获附近wifi 数据
扫描数据
*/
public void scanCurrentLocationWifiData(){
List<ScanResult> scanResults = mWiFiManager.getScanResults();
initScanDate(scanResults);
}
/**
获取扫描数据
*/
public void getScanResult(){
mWiFiManager.startScan();
}
/**
* WIFI列表刷新后的回调
*
* @param scanResults 扫描结果
*/
public void onScanResults(List<ScanResult> scanResults) {
initScanDate(scanResults);
}
/**
* WIFI连接中的信息回调
* @param wifiName wifi名称
* @param connectionType 连接类型 0未连接 1连接成功 2正在连接
*/
public void onWifiIsConnecting(String wifiName, int connectionType) {
wifiBeans = mWiFiManager.changeStateWhenWifiIsConnected(wifiName, connectionType);
updteConnectStatechangeList(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.GetQtWifiChanges("正在连接");
}
}
/**
* wifi 连接失败
* @param wifiName
* @param connectionType
*/
public void onWiFiConnectFailure(String wifiName, int connectionType) {
wifiBeans = mWiFiManager.changeStateWhenWifiIsConnected(wifiName, connectionType);
updteConnectStatechangeList(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.GetQtWifiChanges("连接失败");
}
}
/**
* wifi 密码错误
* @param errorMsg 错误信息 1 密码错误
* @param wifiName wifi名称
* @param connectionType 连接类型 0未连接 1连接成功 2正在连接
*/
public void onWiFiConnectAuthenticatingError(int errorMsg, String wifiName, int connectionType) {
if(errorMsg==1) {
wifiBeans = mWiFiManager.changeStateWhenWifiIsConnected(wifiName, connectionType);
updteConnectStatechangeList(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.GetQtWifiChanges("密码错误");
}
}
}
/**
* WIFI连接成功的回调
* @param wifiName wifi名称
* @param connectionType 连接类型 0未连接 1连接成功 2正在连接
*/
public void onWiFiConnectSuccess(String SSID, int connectType) {
wifiBeans = mWiFiManager.changeStateWhenWifiIsConnected(SSID, connectType);
updteConnectStatechangeList(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.GetQtWifiChanges("连接成功");
}
}
/**
* WIFI开关状态的回调
*
* @param enabled true 可用 false 不可用
*/
public void onWifiEnabled(boolean enabled) {
Log.e(TAG, "WIFI开关状态的回调enabled=" + enabled);
}
/**
连接wifi
@param position mList对应的位置
@param wifiName 名称
@param password 密码
*/
public String connectWifi(String capabilities,String wifiName,String password ){
String iswhetherSucceed="失败";
boolean whetherSucceed=false;
Log.e(TAG, "WIFI连接方法 capabilities" + capabilities+";wifiName="+wifiName+";password="+password);
switch (mWiFiManager.getSecurityModeStr(capabilities)) {
case WPA:
case WPA2:
whetherSucceed = mWiFiManager.connectWPA2Network(wifiName, password);
break;
case WEP:
whetherSucceed= mWiFiManager.connectWEPNetwork(wifiName, password);
break;
case OPEN: // 开放网络
whetherSucceed = mWiFiManager.connectOpenNetwork(wifiName);
break;
}
if(whetherSucceed){
iswhetherSucceed="成功";
}else{
iswhetherSucceed="失败";
}
return iswhetherSucceed;
}
/**
断开wifi
@param position mList对应的位置
*/
public String disconnectWifi(String ssid ){
String disconnectSuccessfully ="失败";
WifiInfo connectionInfo = mWiFiManager.getConnectionInfo();
Log.e(TAG, "onClick: connectionInfo :" + connectionInfo.getSSID());
if (mWiFiManager.addDoubleQuotation(ssid).equals(connectionInfo.getSSID())) {
boolean successfully= mWiFiManager.disconnectWifi(connectionInfo.getNetworkId());
//mWiFiManager.disconnectwifi();
if(successfully){
disconnectSuccessfully="断开成功";
}else{
disconnectSuccessfully="断开失败";
}
}
return disconnectSuccessfully;
}
/**
取消保存配置
*/
public String removeWifi(String ssid){
String removedSuccessfully ="没有保存";
WifiConfiguration wifiConfiguration = mWiFiManager.getConfigFromConfiguredNetworksBySsid(ssid);
if (null != wifiConfiguration) {
boolean isDelete = mWiFiManager.deleteConfig(wifiConfiguration.networkId);
if(isDelete){
removedSuccessfully = "删除成功";
}else{
removedSuccessfully = "删除失败";
}
} else {
removedSuccessfully = "没有保存";
}
return removedSuccessfully;
}
/**
通过定位获附近wifi 数据 scanCurrentLocationWifiData()
手动触发扫描 onScanResults()
*/
private void initScanDate(List<ScanResult> scanResults) {
if(scanResults != null && scanResults.size() >= 0 ) {
// for(int j=0;j< scanResults.size();j++){
// Log.e("jason","扫描原始数据="+scanResults.get(j).SSID);
// }
String currentWifiSSID = mWiFiManager.getCurrentWifiSSID();
if(currentWifiSSID.equals("0x")){//当前有wifi连接
mList.clear();
if(wifiBeans!=null){ wifiBeans.clear();}
wifiBeans = mWiFiManager.filterWifiNameIsEmpty(scanResults);
mList.addAll(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.GetQtScanResults("扫描结束");
mjniTools.wifiResultsList(mList);
}
}else{
mList.clear();
if(wifiBeans!=null){ wifiBeans.clear();}
wifiBeans= mWiFiManager.alreadyConnectedAndNeverDisconnectedWifiData(scanResults,currentWifiSSID);
if(wifiBeans!=null &&wifiBeans.size()>0){
mList.addAll(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.GetQtScanResults("扫描结束");
mjniTools.wifiResultsList(mList);
}
}
}
}
}
/**
更新wifi连接过程中数据刷新处理
*/
private void updteConnectStatechangeList(List<WifiBean> wifiBeans) {
if(wifiBeans!=null &&wifiBeans.size() > 0) {
mList.clear();
mList.addAll(wifiBeans);
if(registerCodeState.equals("1")){
mjniTools.wifiResultsList(mList);
}
}
//updateArrayStrings();
}
/***
updateData 给qt 层调用
*/
public String[] updateArrayStrings(){
String[] listk = new String[mList.size()];
if(mList!=null){
for( int i=0;i< mList.size();i++){
WifiBean wifiBean = mList.get(i);
listk[i] = wifiBean.getWifiName()+";"+wifiBean.getMacAddress()+";"+wifiBean.getLevel()+";"+wifiBean.getState()+";"+wifiBean.getCapabilities();
// Log.e(TAG,"updateDatalist转array[]="+listk[i]);
}
return listk;
}
return listk;
}
/**
获取wifi开关状态是否可用
0不可用 1 可用
*/
public int getWifiEnabled(){
int disabling =0;
boolean isEnabled = mWiFiManager.isWifiEnabled();
if(isEnabled){//可用
disabling =1;
}else{//不可用
disabling =0;
}
return disabling;
}
/**
获取注册状态码 1 成功 0失败
*/
public void getRegisterCode(String code){
Log.e("jason","getRegisterCode==="+code);
registerCodeState = code;
Log.e("jason","getRegisterCode==registerCodeState ="+registerCodeState);
}
/**
得到当前连接的WiFi SSID
*/
public String currentConnectionWifiName(){
String currentWifiSSID = mWiFiManager.getCurrentWifiSSID();
return currentWifiSSID;
}
//===========================wifi end=====================================
public void onDestroy() {
super.onDestroy();
Log.e("jason", "AppUpdateActivity========================= onDestroy");
if( mjniTools!=null){
mjniTools =null;
}
// 移除监听
if(mWiFiManager!=null){
Log.e("jason", "onDestroy===移除监听==========mWiFiManager");
mWiFiManager.removeOnWifiEnabledListener();
mWiFiManager.removeOnWifiScanResultsListener();
mWiFiManager.removeOnWifiConnectListener();
}
}
};
QT端(C++)的实现
wifiSettingWidget.h
#ifndef WIFISETTINGWIDGET_H
#define WIFISETTINGWIDGET_H
#include <QWidget>
#include <QString>
#include <QList>
#include <QDebug>
#include <QListWidget>
#include <QTimer>
#include "switchcontrol.h"
#include "customglobal.h"
#include <QFont>
#include <QPalette>
#include "QDialogButtonBox"
#include "QVBoxLayout"
#include <QDebug>
#include <QListWidget>
#include <QListWidgetItem>
#include <QList>
#include <QLabel>
#include <QHBoxLayout>
#include "src/myWidget/wifidialog.h"
#include "src/myWidget/loadwidget.h"
#include "src/myWidget/mycustomdialogwifidisconnectiondialog.h"
#include "src/myWidget/mycustomdialog.h"
#ifdef Q_OS_ANDROID
#include <QAndroidJniObject>
#include <QAndroidJniEnvironment>
#include <QtAndroid>
#include "src/myWidget/interface.h"
#endif
namespace Ui {
class wifiSettingWidget;
}
class wifiSettingWidget : public QWidget
{
Q_OBJECT
public:
explicit wifiSettingWidget(QWidget *parent = 0);
~wifiSettingWidget();
signals:
public:
void currentOnItemClickListener();
void getSwitchStatus(bool isChecked);
void ReturnBackClicked();
void initData(QList<WifiInfoBean> mInfos);
//获取字符串数组（两个方法二选其一）
void getWifiDataStrings();
//获取wifi列表对象 （两个方法二选其一）
void getWifiDataList();
private slots:
//连接wifi
void qtConnectwifi(QString capabilities,QString SSID ,QString PWD);
//断开wifi
void qtDisConnectionWifiCallBack(QString ssid);
//取消保存wifi
void qtRemoveWifiCallBack(QString ssid);
void loadingCompleted();
private:
Ui::wifiSettingWidget *ui;
SwitchControl *control;
QList<WifiInfoBean> mListInfo;
Interface *m_interface;
WifiDialog *m_dialog;//连接wifi对话框
QFont ft;
QPalette pe;
LoadWidget *m_wifiLoad;
MyCustomDialog *m_passwordError;
MyCustomDialogWifiDisconnectionDialog *m_wifiDisconnectionDialog;
};
#endif // WIFISETTINGWIDGET_H
wifiSettingWidget.cpp
#include "wifisettingwidget.h"
#include "ui_wifisettingwidget.h"
#include "src/myWidget/myprogressbar.h"
#include <QDebug>
#include <QListWidget>
#include <QListWidgetItem>
#include <QString>
#include <QStringList>
#include <QList>
#include "QDebug"
#include <QScroller>
#include <QLabel>
#include <QHBoxLayout>
#include <QSettings>
#ifdef Q_OS_ANDROID
#include <QAndroidJniObject>
#include <QAndroidJniEnvironment>
#include <QtAndroid>
#endif
#include<QMetaType>
/**
wifi setting interface
* @brief wifiSettingWidget::wifiSettingWidget
* @param parent
*/
wifiSettingWidget::wifiSettingWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::wifiSettingWidget)
{
ui->setupUi(this);
mListInfo.clear();
connect(ui->mBtnBack, &QPushButton::clicked, this, &wifiSettingWidget::ReturnBackClicked);
//扫描结果回调
connect(Interface::instance,&Interface::ScanEndCallbackSignal,this,[=](){
// getWifiDataStrings();
qDebug()<<"Jason"<<" 接收到扫描结束的通知============="<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz") ;
getWifiDataList();
});
//连接过程中的回调
connect(Interface::instance,&Interface::NotificationWifiChangesCallbackSignal,this,[=](QString notificationStr){
if(notificationStr==QString::fromLocal8Bit("正在连接")){
qDebug()<<"Jason"<<" 正在连接==wifiSettingWidget============="<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz") ;
// getWifiDataStrings();
getWifiDataList();
} else if(notificationStr==QString::fromLocal8Bit("密码错误")){
// getWifiDataStrings();
getWifiDataList();
m_passwordError = new MyCustomDialog();
m_passwordError->move(180,110);
m_passwordError->setWindowFlag(Qt::FramelessWindowHint);
m_passwordError->setWindowModality(Qt::ApplicationModal);
m_passwordError->InitUi(1,false,"","2","");
m_passwordError->setInfo(QString("温馨提示:"),QString("连接密码错误，请重新连接!"),QPixmap(":/image/hinticon/warn.png"));
m_passwordError->setAttribute(Qt::WA_DeleteOnClose);
m_passwordError->show();
}else if(notificationStr==QString::fromLocal8Bit("连接失败")){
// getWifiDataStrings();
getWifiDataList();
}else if(notificationStr==QString::fromLocal8Bit("连接成功")){
// getWifiDataStrings();
getWifiDataList();
}
});
ui->listWidget->setViewMode(QListView::ListMode);//选择列表形式展示
ui->listWidget->setFlow(QListView::TopToBottom);//选择从上到下的方式拖动
//屏蔽横向滚动条
ui->listWidget->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
//屏蔽垂直滚动条
ui->listWidget->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
ui->listWidget->setStyleSheet("background-color:transparent");
//ui->listWidget->update();//刷新界面
// 像素滚动
// ui->listWidget->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
// ui->listWidget->setVerticalScrollMode(QListWidget::ScrollPerPixel);
ui->listWidget->setHorizontalScrollMode(QListWidget::ScrollPerPixel);
// QScroller::grabGesture(ui->listWidget,QScroller::LeftMouseButtonGesture);
/*用connect 连接信号和槽函数*/
QObject::connect(ui->listWidget,&QListWidget::itemClicked,this,&wifiSettingWidget::currentOnItemClickListener);
control= new SwitchControl(this);
control -> move(130,70);
//设置状态、样式
control -> setToggled(false);
// 可设置槽函数控制按钮的开关状态
connect(control,&SwitchControl::toggled,this,&wifiSettingWidget::getSwitchStatus);
// ui->listWidget->setGridSize(QSize(ui->listWidget->width(),55));
int qtWifiEnabled = m_interface->getQtWifiEnabled();
if(qtWifiEnabled==0){
control -> setToggled(false);
ui->listWidget->clear();
}else{
control -> setToggled(true);
m_interface = Interface::getInstance();
m_interface->startScanningQtWifi();
QString wifiName = m_interface->getQtCurrentWifiSSID();
qDebug()<<"jason"<<"wifiSettingWidget="<<"获取当前已经连接wifi名字wifiName="<<wifiName;
if(wifiName==QString::fromLocal8Bit("0x")){
m_wifiLoad =new LoadWidget(this);
m_wifiLoad->move(300,80);
m_wifiLoad->InitializeControls(true);
m_wifiLoad->setCurrentIndex(1);
m_wifiLoad->setWhetherDisplayBackgroundWhileLoading(2);
m_wifiLoad->setCurrentTotal(30);
m_wifiLoad->setLoadingType("加载中...");
m_wifiLoad->setLoadingBoxStyleMode("1");
m_wifiLoad->setWindowFlag(Qt::FramelessWindowHint);
m_wifiLoad->setWindowModality(Qt::ApplicationModal);
m_wifiLoad->setAttribute(Qt::WA_DeleteOnClose);
connect(m_wifiLoad, &LoadWidget::loadingClick, this , &wifiSettingWidget::loadingCompleted);
m_wifiLoad->mShow();
}
}
}
wifiSettingWidget::~wifiSettingWidget()
{
delete ui;
}
/**
获取变化的wifi数据 ----->字符串数组
* @brief wifiSettingWidget::getWifiDataStrings
*/
void wifiSettingWidget::getWifiDataStrings(){
mListInfo.clear();
m_interface = Interface::getInstance();
mListInfo = m_interface->getWifiScanResults();
if(mListInfo.size()!=0 && !mListInfo.isEmpty()){
initData(mListInfo);
}
}
/**
获取变化的wifi数据 ----->字符串数组
* @brief wifiSettingWidget::getWifiDataList
*/
void wifiSettingWidget::getWifiDataList(){
mListInfo.clear();
m_interface =Interface::getInstance();
mListInfo = m_interface->GetWifiObjectList();
if(mListInfo.size()!=0 && !mListInfo.isEmpty()){
initData(mListInfo);
}
}
/**
打开wifi 开关按钮
* @brief MainWindow::getSwitchStatus 获取开关状态
* @param isChecked true 打开 false 关闭
*/
void wifiSettingWidget::getSwitchStatus(bool isChecked ){
if (isChecked) {
qDebug()<<"jason"<<" 打开= "<<isChecked;
m_interface= Interface::getInstance();
m_interface->openQtWifi();
m_interface->startScanningQtWifi();
m_wifiLoad =new LoadWidget(this);
m_wifiLoad->move(300,80);
m_wifiLoad->InitializeControls(true);
m_wifiLoad->setCurrentIndex(1);
m_wifiLoad->setWhetherDisplayBackgroundWhileLoading(2);
m_wifiLoad->setCurrentTotal(40);
m_wifiLoad->setLoadingType("加载中...");
m_wifiLoad->setLoadingBoxStyleMode("1");
m_wifiLoad->setWindowFlag(Qt::FramelessWindowHint);
m_wifiLoad->setWindowModality(Qt::ApplicationModal);
m_wifiLoad->setAttribute(Qt::WA_DeleteOnClose);
connect(m_wifiLoad, &LoadWidget::loadingClick, this , &wifiSettingWidget::loadingCompleted);
m_wifiLoad->mShow();
} else {
qDebug()<<"jason"<<" 关闭= "<<isChecked;
m_interface = Interface::getInstance();
m_interface->closeQtWifi();
mListInfo.clear();
ui->listWidget->clear();
}
}
/**
listview 点击item 事件
当前点击QlistWidget 中哪一个条目
* @brief MainWindow::currentOnItemClickListener
*/
void wifiSettingWidget::currentOnItemClickListener()
{
//我们也不做过多的操作我们可以获取打印出当前选中的项目的文本数据
int CurrentRow = ui->listWidget->currentRow();
if(CurrentRow!=-1)
{
ui->listWidget->item(CurrentRow);
if(mListInfo.at(CurrentRow).state==QString::fromLocal8Bit("未连接")){
m_dialog =new WifiDialog(this);
m_dialog->move(260,110);
m_dialog->setWindowFlag(Qt::FramelessWindowHint);
m_dialog->setWindowModality(Qt::ApplicationModal);
m_dialog->setAttribute(Qt::WA_DeleteOnClose);
// m_dialog->initWifiDialog(mListInfo.at(CurrentRow).SSID,mListInfo.at(CurrentRow).state,CurrentRow);
m_dialog->initWifiDialog(mListInfo.at(CurrentRow).keytype,mListInfo.at(CurrentRow).SSID,mListInfo.at(CurrentRow).state);
if (QDialogButtonBox *btn_box = m_dialog->findChild<QDialogButtonBox*>() ){
//设置button之间的间距
btn_box->layout()->setSpacing(50);
QString ok_style = "QPushButton{background:rgb(34, 166, 232); color:rgb(255,255,255); border-radius:10px; min-height:60px; min-width:130px; font:36px \"Microsoft YaHei\";}"
"QPushButton:hover{background:rgb(34, 167, 229);}"
"QPushButton:pressed{background:rgb(34, 167, 229);}";
btn_box->button(QDialogButtonBox::Ok)->setText("连接");
btn_box->button(QDialogButtonBox::Ok)->setStyleSheet(ok_style);
QString cancel_style = "QPushButton{background:rgb(207, 222, 236); color:rgb(255,255,255); border-radius:10px; min-height:60px; min-width:130px; font:36px \"Microsoft YaHei\";}"
"QPushButton:hover{background:rgb(207, 222, 236);}"
"QPushButton:pressed{background:rgb(207, 222, 236);}";
btn_box->button(QDialogButtonBox::Cancel)->setText("取消");
btn_box->button(QDialogButtonBox::Cancel)->setStyleSheet(cancel_style);
}
QString style = "QLineEdit{border:2px solid rgb(34, 166, 232);padding-left:15px;border-radius:10px;color:rgb(34, 166, 232);font:22px \"Microsoft YaHei\";}"
"QLineEdit:focus{border:2px solid rgb(34, 166, 232);}"
"QLineEdit:disabled{background-color:rgb(255,255,255);}"
"QLabel{color:rgb(34, 167, 229); font:24px \"Microsoft YaHei\"; font-weight:bold;}";
m_dialog->setStyleSheet(style);
//连接wifi 刷新连接状态
connect(m_dialog, &WifiDialog::connectCurrentWifi, this , &wifiSettingWidget::qtConnectwifi);
m_dialog->show();
}else if(mListInfo.at(CurrentRow).state==QString::fromLocal8Bit("已连接")){
m_wifiDisconnectionDialog =new MyCustomDialogWifiDisconnectionDialog();
m_wifiDisconnectionDialog->move(180,110);
m_wifiDisconnectionDialog->setWindowFlag(Qt::FramelessWindowHint);
m_wifiDisconnectionDialog->setWindowModality(Qt::ApplicationModal);
m_wifiDisconnectionDialog->InitUi(3,false,"取消保存","断开");
m_wifiDisconnectionDialog->setInfo(mListInfo.at(CurrentRow).SSID,mListInfo.at(CurrentRow).state);
m_wifiDisconnectionDialog->setAttribute(Qt::WA_DeleteOnClose);
connect(m_wifiDisconnectionDialog, &MyCustomDialogWifiDisconnectionDialog::disconnectCallbcak, this , &wifiSettingWidget::qtDisConnectionWifiCallBack);
//删除wifi
connect(m_wifiDisconnectionDialog, &MyCustomDialogWifiDisconnectionDialog::cancelSaveCallback, this , &wifiSettingWidget::qtRemoveWifiCallBack);
m_wifiDisconnectionDialog->show();
}
}
}
/**
连接wifi
* @brief wifiSettingWidget::qtConnectwifi
* @param SSID
* @param PWD
* @param capabilities
*/
void wifiSettingWidget:: qtConnectwifi(QString capabilities,QString SSID ,QString PWD){
m_interface = Interface::getInstance();
m_interface->connectQtWifi(capabilities,SSID,PWD);
// if(mListInfo.size()>0){
// mListInfo.clear();
// }
// ui->listWidget->clear();
}
/**
断开连接
* @brief wifiSettingWidget::qtDisConnectionWifiCallBack
* @param position
*/
void wifiSettingWidget::qtDisConnectionWifiCallBack(QString ssid){
m_interface = Interface::getInstance();
m_interface->disConnectionQtWifi(ssid);
// if(mListInfo.size()>0){
// mListInfo.clear();
// }
// ui->listWidget->clear();
}
/**
删除保存wifi
* @brief wifiSettingWidget::qtRemoveWifiCallBack
* @param position
*/
void wifiSettingWidget::qtRemoveWifiCallBack(QString ssid)
{
m_interface = Interface::getInstance();
m_interface->removeQtWifi(ssid);
// if(mListInfo.size()>0){
// mListInfo.clear();
// }
// ui->listWidget->clear();
}
/**
加载完成
* @brief wifiSettingWidget::loadingCompleted
*/
void wifiSettingWidget::loadingCompleted()
{
m_wifiLoad->mClose();
// m_interface = Interface::getInstance();
// m_interface->startScanningQtWifi();
initData(mListInfo);
}
/**
返回按钮
* @brief wifiSettingWidget::on_pushButton_clicked
*/
void wifiSettingWidget::ReturnBackClicked()
{
this->close();
}
/**
初始化数据
* @brief wifiSettingWidget::initData
* @param mInfos
*/
void wifiSettingWidget::initData(QList<WifiInfoBean> mInfos)
{
ui->listWidget->clear();
if(mInfos.size()!=0 && !mInfos.isEmpty()){
for (int j =0;j<mInfos.size();j++) {
QWidget *widget = new QWidget(ui->listWidget);
//创建自定义的item
widget->setStyleSheet("background:transparent;");
//设置图片icon
QLabel *imageIcon = new QLabel(widget);
QPixmap myPix(":/image/wifi/wifiicon.png");
imageIcon->setFixedSize(70, 42);
imageIcon->setPixmap(myPix);
imageIcon->setScaledContents(true);
imageIcon->setStyleSheet("QLabel{padding-left:15px;padding-right:15px;}");
QWidget *frontArea = new QWidget(widget);
//设置固定高度
frontArea->setFixedHeight(42);
//wifi名字
QLabel *wifiName = new QLabel(frontArea);
ft.setPointSize(32);
ft.bold();
if(mInfos.at(j).state == QString::fromLocal8Bit("已连接")){
pe.setColor(QPalette::Text, Qt::blue);
}else if(mInfos.at(j).state == QString::fromLocal8Bit("正在连接")){
pe.setColor(QPalette::Text, Qt::blue);
}else{
pe.setColor(QPalette::Text, Qt::black);
}
wifiName->setPalette(pe);
//设置字体大小
wifiName->setFont(ft);
wifiName->setText(mInfos.at(j).SSID);
//连接状态
QLabel * wifiStatus = new QLabel(frontArea);
ft.setPointSize(26);
if(mInfos.at(j).state == QString::fromLocal8Bit("已连接")){
pe.setColor(QPalette::Text, Qt::blue);
}else if(mInfos.at(j).state == QString::fromLocal8Bit("正在连接")){
pe.setColor(QPalette::Text, Qt::blue);
}else{
pe.setColor(QPalette::Text, Qt::black);
}
//设置字体大小
wifiStatus->setFont(ft);
wifiStatus->setPalette(pe);
wifiStatus->setText(mInfos.at(j).state);
wifiStatus->setContentsMargins(0,0,0,0);
//QWidget 包含 mac地址和加密类型
// QWidget *backArea = new QWidget(widget);
// backArea->setFixedSize(80, 42);
// QLabel *wifiMac = new QLabel(backArea);
// wifiMac->setText(mInfos.at(j).BSSID);
// QLabel *wifiEncryption = new QLabel(backArea);
// wifiEncryption->setText(mInfos.at(j).keytype);
// wifiEncryption->setContentsMargins(0,10,0,0);
QVBoxLayout *verLayout = new QVBoxLayout;//垂直布局 上到下排列
verLayout->setContentsMargins(0, 0, 0, 0);
verLayout->setMargin(0);
verLayout->setSpacing(0);
verLayout->addWidget(wifiName);
verLayout->addWidget(wifiStatus);
frontArea->setLayout(verLayout);
// QVBoxLayout *verLayout2 = new QVBoxLayout;//垂直布局 上到下排列
// verLayout2->setContentsMargins(0, 0, 0, 0);// 设置垂直布局外间距
// verLayout2->setMargin(0);//设置垂直布局的边距
// verLayout2->setSpacing(0);//设置垂直布局的间距
// verLayout2->addWidget(wifiMac);
// verLayout2->addWidget(wifiEncryption);
// backArea->setLayout(verLayout2);
QHBoxLayout *horLayout = new QHBoxLayout;//水平布局左右排列
horLayout->setContentsMargins(0, 0, 0, 0); // 设置水平布局外间距
horLayout->setMargin(0);//设置水平布局的边距
horLayout->setSpacing(0);//设置水平布局的间距
horLayout->addWidget(imageIcon);
horLayout->addWidget(frontArea);
// horLayout->addWidget(backArea);
widget->setLayout(horLayout);
//将widget作为列表的item
QListWidgetItem *m_item = new QListWidgetItem();
QSize size = m_item->sizeHint();
m_item->setSizeHint(QSize(size.width(), 65));
ui->listWidget->addItem(m_item);
widget->setSizeIncrement(size.width(), 65);//设置大小增量
// m_item->setTextAlignment(Qt::AlignHCenter);
ui->listWidget->setItemWidget(m_item, widget);
}
}
}
mycustomdialogwifidisconnectiondialog.h
#ifndef MYCUSTOMDIALOGWIFIDISCONNECTIONDIALOG_H
#define MYCUSTOMDIALOGWIFIDISCONNECTIONDIALOG_H
#include <QDialog>
#include <QPushButton>
#include <QLabel>
#include <QMouseEvent>
#include <QFont>
#include <QPixmap>
#include <QPainter>
#include <QBitmap>
#include <QTimer>
#include <QMessageBox>
#include <QDebug>
class MyCustomDialogWifiDisconnectionDialog:public QDialog
{
Q_OBJECT
public:
MyCustomDialogWifiDisconnectionDialog(QWidget *parent = 0);
~MyCustomDialogWifiDisconnectionDialog();
signals:
//取消保存
void cancelSaveCallback(QString ssid);
// void ConfirmCallback(QString path);
//断开
void disconnectCallbcak(QString ssid);
//取消
void CancelCallbcak();
public:
QPushButton *btnCancelSave;
QPushButton *btnDisconnect;
QPushButton *btnCancel;
QLabel *ask_label;
QLabel *msg_label;
QString ok_text;
QString cancel_text;
public:
void setInfo(QString name,QString state);
QString getwifiName();
void InitUi(int type,bool is_title_hidden,QString btntText,QString otherbtntText);
void setCurrentIndex(int inputIndex);
void setCurrentTotal(int inputTotal);
protected:
QPoint move_point;
bool mouse_press;
void paintEvent(QPaintEvent *);
public slots:
void CancelSaveOperate();
void DisconnectOperate();
void CancelOperate();
private:
QString wifiSSid;
};
#endif // MYCUSTOMDIALOGWIFIDISCONNECTIONDIALOG_H
mycustomdialogwifidisconnectiondialog.cpp
#include "mycustomdialogwifidisconnectiondialog.h"
MyCustomDialogWifiDisconnectionDialog::MyCustomDialogWifiDisconnectionDialog(QWidget *parent): QDialog(parent)
{
}
MyCustomDialogWifiDisconnectionDialog::~MyCustomDialogWifiDisconnectionDialog(){
}
/**
* @brief MsgBox::InitUi 初始化控件
* @param type 参数为1时对话框只有一个按钮 参数为2时对话框只有两个按钮 参数为3时对话框只有三个按钮
* @param is_title_hidden true不显示标题 false 显示标题
* @param btntText 默认确认
* @param otherbtntText 其他按钮设置内容 为空显示默认值
*/
void MyCustomDialogWifiDisconnectionDialog::InitUi(int type,bool is_title_hidden,QString btntText ,QString otherbtntText){
this->resize(500, 260);
//获取主界面的宽度
int width = this->width();
int height = this->height();
//初始化为未按下鼠标左键
mouse_press = false;
//设置标题栏隐藏
this->setWindowFlags(Qt::FramelessWindowHint | Qt::Dialog);
//设置提示信息，让QLabel能够自动判断并换行显示：
ask_label = new QLabel(this);
QFont mfont = ask_label->font();
mfont.setPointSize(28);
ask_label->setFont(mfont);
ask_label->setWordWrap(true);
ask_label->setAlignment(Qt::AlignHCenter|Qt::AlignVCenter);//手动设置靠右居中对齐
ask_label->setIndent(10);//文本缩进 仅左右
// ask_label->setMargin(20);//设置内容范围的边框与控件边框的间距，上下左右
// ask_label->setGeometry(65, 90, width-85, 25*2);
ask_label->setGeometry(100, 30, 300, 58);
ask_label->setStyleSheet("QLabel{border:2px solid rgb(34, 166, 232);padding-left:15px;border-radius:10px;color:rgb(34, 166, 232);}");
//连接状态
msg_label = new QLabel(this);
QFont mfont1 = msg_label->font();
mfont1.setPointSize(28);
msg_label->setFont(mfont);
msg_label->setWordWrap(true);
msg_label->setAlignment(Qt::AlignHCenter|Qt::AlignVCenter);//手动设置靠右居中对齐
msg_label->setIndent(10);//文本缩进 仅左右
msg_label->setGeometry(100, 110, 300, 58);
msg_label->setStyleSheet("QLabel{border:2px solid rgb(34, 166, 232);padding-left:15px;border-radius:10px;color:rgb(34, 166, 232);}");
if(btntText == QString::fromLocal8Bit("")){
btntText = tr("取消保存");
}
if(otherbtntText == QString::fromLocal8Bit("")){
otherbtntText = tr("断开");
}
if(type ==3){//只显示三个button按钮
btnCancelSave = new QPushButton(this);
btnDisconnect = new QPushButton(this);
btnCancel = new QPushButton(this);
QString okBtn_style = "QPushButton{background:rgb(34, 166, 232); color:rgb(255,255,255); border-radius:10px; min-height:60px; min-width:100px; font:24px \"Microsoft YaHei\";}"
"QPushButton:hover{background:rgb(34, 167, 229);}"
"QPushButton:pressed{background:rgb(34, 167, 229);}";
btnCancelSave->setStyleSheet(okBtn_style);
QString otherBtn_style = "QPushButton{background:rgb(34, 166, 232); color:rgb(255,255,255); border-radius:10px; min-height:60px; min-width:100px; font:24px \"Microsoft YaHei\";}"
"QPushButton:hover{background:rgb(34, 167, 229);}"
"QPushButton:pressed{background:rgb(34, 167, 229);}";
btnDisconnect->setStyleSheet(otherBtn_style);
QString cancelBtn_style = "QPushButton{background:rgb(207, 222, 236); color:rgb(255,255,255); border-radius:10px; min-height:60px; min-width:100; font:24px \"Microsoft YaHei\";}"
"QPushButton:hover{background:rgb(207, 222, 236);}"
"QPushButton:pressed{background:rgb(207, 222, 236);}";
btnCancel->setStyleSheet(cancelBtn_style);
// QString style = "QLineEdit{border:2px solid rgb(34, 166, 232);padding-left:15px;border-radius:10px;color:rgb(34, 166, 232);font:22px \"Microsoft YaHei\";}"
// "QLineEdit:focus{border:2px solid rgb(34, 166, 232);}"
// "QLineEdit:disabled{background-color:rgb(255,255,255);}"
// "QLabel{color:rgb(34, 167, 229); font:24px \"Microsoft YaHei\"; font-weight:bold;}";
btnCancelSave->resize(140, 48);
btnCancelSave->move(width - btnCancelSave->width() - 20, height - 80);
btnDisconnect->resize(140, 48);
btnDisconnect->move(width-btnCancelSave->width()- btnCancelSave->width() - 40, height - 80);
btnCancel->resize(140, 48);
btnCancel->move(width -btnCancel->width() - btnDisconnect->width()- btnCancelSave->width()- 60, height - 80);
btnCancelSave->setObjectName(QString::fromUtf8("pushButtonTwo"));
btnDisconnect->setObjectName(QString::fromUtf8("pushButtonTwo"));
btnCancel->setObjectName(QString::fromUtf8("pushButtonTwo"));
btnCancelSave->setText(btntText);
btnCancel->setText(tr("取消"));
btnDisconnect->setText(otherbtntText);
//设置默认按钮为取消按钮
btnCancel->setFocus();
QObject::connect(btnCancelSave, SIGNAL(clicked()), this, SLOT(CancelSaveOperate()));
QObject::connect(btnDisconnect, SIGNAL(clicked()), this, SLOT(DisconnectOperate()));
QObject::connect(btnCancel, SIGNAL(clicked()), this, SLOT(CancelOperate()));
}
}
//设置对话框信息
void MyCustomDialogWifiDisconnectionDialog::setInfo(QString name,QString state)
{
this->wifiSSid = name;
//设置提示信息
ask_label->setText("WIFI名称:\r"+name);
msg_label->setText("状态信息:\r"+state);
}
QString MyCustomDialogWifiDisconnectionDialog::getwifiName()
{
return wifiSSid;
}
void MyCustomDialogWifiDisconnectionDialog::paintEvent(QPaintEvent *)
{
QPainter painter(this);
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
painter.setBrush(QBrush(QColor(255, 255, 255)));
painter.setPen(Qt::transparent);
QRect mRect = this->rect();
mRect.setWidth(mRect.width() - 1);
mRect.setHeight(mRect.height() - 1);
// painter.drawRoundedRect(rect, 20, 20);
//也可用QPainterPath 绘制代替 painter.drawRoundedRect(rect, 15, 15);
QPainterPath painterPath;
painterPath.addRoundedRect(mRect, 0, 0);
painter.drawPath(painterPath);
}
//确认操作
void MyCustomDialogWifiDisconnectionDialog::CancelSaveOperate()
{
qDebug()<<"确认操作";
emit cancelSaveCallback(getwifiName());
done(Accepted);
}
//取消操作
void MyCustomDialogWifiDisconnectionDialog::CancelOperate()
{
qDebug()<<"取消操作";
emit CancelCallbcak();
done(Rejected);
}
//其他窗体操作
void MyCustomDialogWifiDisconnectionDialog::DisconnectOperate()
{
qDebug()<<"其他操作";
emit disconnectCallbcak(getwifiName());
done(Accepted);
}
android 端当wifi变化的状态主动传送给qt层（**重点）
Interface.h
#ifndef INTERFACE_H
#define INTERFACE_H
#include <QObject>
#include <QStringList>
#ifdef ANDROID
#include <QtAndroidExtras/QAndroidJniObject>
#include <QAndroidJniEnvironment>
#include <QtAndroid>
#include<jni.h>
#endif
struct WifiInfoBean{
QString SSID;
QString BSSID;
QString level;
QString state;
QString keytype;
};
class Interface : public QObject
{
Q_OBJECT
public:
static Interface* instance;
explicit Interface(QObject *parent = nullptr);
~Interface();
public:
static Interface *getInstance();
//扫码结果的回调
static void getQtWifiScanResults(JNIEnv *env, jclass clzz,jstring jstr);
//连接wifi 过程中 各种回调
static void getWifiChangesState(JNIEnv *env, jclass clzz,jstring jstr);
//返回连接过程中刷新数据结果
static void getQtConnectingResults(JNIEnv *env, jclass thiz,jobjectArray stringArray);
bool registerNativeMethods();
//传递wifilist对象
static void getQtwifiResultsList(JNIEnv *env, jclass thiz,jobject wifilist);
//扫描结束回调
void ScanEndCallback(QString str);
//连接发生变化通知
void notificationWifiChangesCallBack(QString notification);
//java传递过来的List<wifibean>对象；
void getWifiScanResultsList(QList<WifiInfoBean> mlist);
signals:
//扫描结束通知 信号
void ScanEndCallbackSignal();
//连接wifi过程中的通知 信号
void NotificationWifiChangesCallbackSignal(QString notificationStr);
public slots:
//打开wifi
void openQtWifi();
//关闭wifi
void closeQtWifi();
//开始扫描wifi
void startScanningQtWifi();
//获取wifi 开启状态
int getQtWifiEnabled();
//获取当前已经连接的wifi
QString getQtCurrentWifiSSID();
//获取java 调用注册是否成功
void getQtRegisterJavaCode(QString registerCode);
//连接wifi
void connectQtWifi(QString capabilities,QString SSID ,QString PWD);
//断开wifi连接
void disConnectionQtWifi(QString ssid );
//取消保存
void removeQtWifi(QString ssid );
//获取wifi扫描结果的数据列表
QList<WifiInfoBean> getWifiScanResults();
QList<WifiInfoBean> GetWifiObjectList();
private:
QList<WifiInfoBean> wifiList;
};
#endif // INTERFACE_H
Interface.cpp
#include "interface.h"
#include <QDebug>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include<android/log.h>
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "jason", __VA_ARGS__))
#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN, "jason", __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "jason", __VA_ARGS__))
//输入法 https://juejin.cn/post/7156015823180529694
/**
java调用qt
* @brief Interface::instance
* android内存泄露之jnilocalreferencetableoverflow(max=512)
* 链接 https://www.php1.cn/detail/web.html
* 链接:
* https://developer.aliyun.com/article/858081
* JNI手动释放内存（避免内存泄露）
* https://www.cnblogs.com/Free-Thinker/p/10615107.html
* 参考连接
* http://www.cnblogs.com/qinjunni/archive/2012/02/20/2359181.html
*/
Interface* Interface::instance = nullptr;
Interface::Interface(QObject *parent) : QObject(parent)
{
}
Interface::~Interface()
{
// delete instance;
instance->deleteLater();
}
Interface *Interface::getInstance()
{
if(instance == nullptr)
{
instance = new Interface();
}
return instance;
}
/**
registerNativeMethods java类中的函数与c++中函数绑定
* @brief Interface::registerNativeMethods
* @return 成功 失败
*
* typedef struct {
const char* name;
const char* signature;
void* fnPtr;
} JNINativeMethod;
第一个变量name是Java中函数的名字。
第二个变量signature，用字符串是描述了函数的参数和返回值
第三个变量fnPtr是函数指针，指向C函数。
*/
bool Interface::registerNativeMethods()
{
JNINativeMethod methods[]{
{"GetQtScanResults", "(Ljava/lang/String;)V", (void*)getQtWifiScanResults},
{"GetQtWifiChanges", "(Ljava/lang/String;)V", (void*)getWifiChangesState},
{"wifiResultsList", "(Ljava/util/List;)V", (void*)getQtwifiResultsList}
};
jclass clazz;
QAndroidJniEnvironment env;
QAndroidJniObject javaClass("org/qtproject/example/NativeTools");
clazz = env->GetObjectClass(javaClass.object<jobject>());
bool result = false;
if(clazz)
{
jint ret = env->RegisterNatives(clazz, methods, sizeof (methods) / sizeof (methods[0]));
env->DeleteLocalRef(clazz);
result = ret >= 0;
}
if(env->ExceptionCheck())
env->ExceptionClear();
return result;
}
/**
创建指定长度数组
native和static native区别
public native String helloJni();
public native static String helloJniStatic();
区别在于第二个参数是jobject还是jclass，和java中static方法属于类而不属于对象一样，static 的native方法属于类，所以第二个参数是jclass而不是jobject。
JNIEXPORT jstring JNICALL Java_com_test_git_jnidemo_JniUtil_JniDemo_helloJni
(JNIEnv *, jobject);
JNIEXPORT jstring JNICALL Java_com_test_git_jnidemo_JniUtil_JniDemo_helloJniStatic
(JNIEnv *, jclass);
jobject获取jclass
jclass cls = env->GetObjectClass(jobj);
jclass获取jobject
jmethodID cid = env->GetMethodID(cls, "<init>", "()V");
jobject jobj = env->NewObject(cls, cid);注意：这里获取到的jobj已经是一个新的对象。
*/
void Interface::getQtWifiScanResults(__attribute__((unused))JNIEnv *env, __attribute__((unused))jclass clzz,__attribute__((unused))jstring jstr){
const char *a = env->GetStringUTFChars(jstr,NULL);
QString qstr=QString(a);
Interface::getInstance()->ScanEndCallback(qstr);
env->ReleaseStringUTFChars(jstr,a);
env->DeleteLocalRef(jstr);
env->DeleteLocalRef(clzz);
}
/**
java 主动调用qt
扫描发生变化通知qt 刷新ui界面
* @brief Interface::ScanEndCallback
* @param str
*/
void Interface::ScanEndCallback(QString str){
emit ScanEndCallbackSignal();
}
/**
java 主动调用qt
wifi连接过程中状态发生变化
java需要主动通知qt
连接中 失败 密码错误 成功
*/
void Interface::getWifiChangesState(__attribute__((unused))JNIEnv *env, __attribute__((unused))jclass clzz,__attribute__((unused))jstring jstr){
const char *notification = env->GetStringUTFChars(jstr,NULL);
QString qnotification=QString(notification);
Interface::getInstance()->notificationWifiChangesCallBack(qnotification);
env->ReleaseStringUTFChars(jstr,notification);
env->DeleteLocalRef(jstr);
env->DeleteLocalRef(clzz);
}
/**
java 主动调用qt
通知qt wifi状态发生变化了刷新ui
* @brief Interface::notificationWifiChangesCallBack
* @param notification
*/
void Interface::notificationWifiChangesCallBack(QString notification){
emit NotificationWifiChangesCallbackSignal(notification);
}
/**
打开wifi qt主动调用java
* @brief Interface::openQtWifi
*/
void Interface::openQtWifi()
{
#ifdef Q_OS_ANDROID
QAndroidJniObject activity = QtAndroid::androidActivity();
activity.callMethod<void>("openSystemWiFi");
QAndroidJniEnvironment env;
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
/**
开始扫描wifi qt主动调用java
* @brief Interface::startScanningQtWifi
*/
void Interface::startScanningQtWifi(){
#ifdef Q_OS_ANDROID
QAndroidJniObject activity = QtAndroid::androidActivity();
activity.callMethod<void>("getScanResult");
QAndroidJniEnvironment env;
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
/**关闭wifi qt主动调用java
* @brief Interface::closeQtWifi
*/
void Interface::closeQtWifi()
{
#ifdef Q_OS_ANDROID
QAndroidJniObject activity = QtAndroid::androidActivity();
activity.callMethod<void>("closeSystemWiFi");
QAndroidJniEnvironment env;
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
/**
获取当前已经连接的wifi名称
* @brief Interface::getQtCurrentWifiSSID
* @return
*/
QString Interface::getQtCurrentWifiSSID(){
#ifdef Q_OS_ANDROID
QAndroidJniEnvironment env;
QAndroidJniObject activity = QtAndroid::androidActivity();
QAndroidJniObject ss= activity.callObjectMethod("currentConnectionWifiName", "()Ljava/lang/String;");
jstring string_java_wifi_name = static_cast<jstring>(ss.object());
const char *c_str_wifi_name = env->GetStringUTFChars(string_java_wifi_name, 0);
QString currentWifiName = QString(c_str_wifi_name);
qDebug()<< "当前连接的是=" <<currentWifiName;
env->ReleaseStringUTFChars(string_java_wifi_name,c_str_wifi_name);
env->DeleteLocalRef(ss.object());
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
return currentWifiName;
#endif
}
/**
qt主动调用java 获取系统wifi开关是否打开
* @brief Interface::getQtWifiEnabled
* @return 获取wifi是否打开 状态 0不可用 1 可用
*/
int Interface::getQtWifiEnabled()
{
#ifdef Q_OS_ANDROID
QAndroidJniEnvironment env;
QAndroidJniObject activity = QtAndroid::androidActivity();
jint n = activity.callMethod<jint>("getWifiEnabled", "()I");
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
return n;
#endif
}
/**
qt启动界面晚于Android 需要判断是否在main.cpp中注册成功
如果qt注册成功，Android 才能调用通知给qt wifi列表发生变化了
* @brief Interface::getQtRegisterJavaCode
* @return
*/
void Interface::getQtRegisterJavaCode(QString registerCode)
{
#ifdef Q_OS_ANDROID
QAndroidJniEnvironment env;
QAndroidJniObject activity = QtAndroid::androidActivity();
QAndroidJniObject obj = QAndroidJniObject::fromString(registerCode);
jstring string_java_code = static_cast<jstring>(obj.object());
const char *c_str_code = env->GetStringUTFChars(string_java_code, 0);
activity.callMethod<void>("getRegisterCode","(Ljava/lang/String;)V",string_java_code);
//释放资源
registerCode ="";
env->ReleaseStringUTFChars(string_java_code,c_str_code);
env->DeleteLocalRef(string_java_code);
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
/**
方式一 获取wifi字符串数组数据
* @brief Interface::getWifiScanResults
1.获取字符串数组的长度
jsize stringArrayLength = env->GetArrayLength(stringArray);
2.遍历字符串数组
for(int i =0;i<stringArrayLength;i++){
2.1 获取 jobject 数组中第 i 个元素
注意 : 获取的是 jobject 类型变量
函数原型 : jobject GetObjectArrayElement(jobjectArray array, jsize index)
jobjectArray array 参数 : 是 Java 层传入的 Java 对象数组 参数 , 即 Native 层的调用函数的参数
jsize index 参数 : 对象元素的索引值 , 取值范围 0 ~ stringArrayLength - 1
返回值 : 返回的是 jobject 类型的变量
jobject string_object = env->GetObjectArrayElement(stringArray, i);
2.2 将 jobject 类型强转成 jstring 类型 , 这两个都代表了 Java 的数据类型
jstring string_java = static_cast<jstring>(string_object);
2.3 将 jstring 类型转为 char* 类型
jstring 类型简介 :
class _jobject {};
class _jstring : public _jobject {};
typedef _jstring* jstring;
由上面可见 , jstring 只是 继承了 _jobject 类 , 没有任何实现 , 是一个空类
因此需要借助 C/C++ 方法 将 java 类型的 jstring 字符串 其转为 C/C++ 类型的 char* 类型字符串
转换函数原型 : void ReleaseStringUTFChars(jstring string, const char* utf)
const char *string_c = env->GetStringUTFChars(string_java, 0);
2.4 打印 转换后的 字符串值
qDebug()<<"打印字符串数组元素 : i="<<i<<" ;string_c="<<string_c;
2.5 释放 char* 字符串
env->ReleaseStringUTFChars(string_java, string_c);
*/
QList<WifiInfoBean> Interface::getWifiScanResults()
{
#ifdef Q_OS_ANDROID
wifiList.clear();
QAndroidJniEnvironment env;
QAndroidJniObject activity = QtAndroid::androidActivity();
QAndroidJniObject strjobjectArray = activity.callObjectMethod("updateArrayStrings", "()[Ljava/lang/String;");
jobjectArray objectArray = strjobjectArray.object<jobjectArray>();
const int size = env->GetArrayLength(objectArray);
for (int i = 0; i < size; i++) {
//遍历string数组获取到 jobject对象
jobject java_object = env->GetObjectArrayElement(objectArray, i);
//将 jobject 类型强转成 jstring 类型 , 这两个都代表了 Java 的数据类型
jstring string_java = static_cast<jstring>(java_object);
const char *string_c = env->GetStringUTFChars(string_java, 0);
QString str =QString(string_c);
//切割字符串数组
QStringList cuttingData = str.split(";");
WifiInfoBean *info=new WifiInfoBean();
info->SSID =cuttingData[0];
info->BSSID=cuttingData[1];
info->level=cuttingData[2];
info->state =cuttingData[3];
info->keytype=cuttingData[4];
wifiList.append(*info);
//释放结构体
delete info;
env->ReleaseStringUTFChars(string_java,string_c);
env->DeleteLocalRef(java_object);
}
objectArray =nullptr;
strjobjectArray=nullptr;
//释放数组 删除全局对象的引用
env->DeleteGlobalRef(objectArray);
env->DeleteLocalRef(strjobjectArray.object());
if(env->ExceptionCheck())
{
env->ExceptionDescribe();
env->ExceptionClear();
}
return wifiList;
#endif
}
/**
方式二 获取wifi列表对象数据 QList<WifiInfoBean>
java和C++互传ArrayList泛型对象参数
* @brief Interface::getQtwifiResultsList
* @param env
* @param thiz
* @param wifilist
*/
void Interface::getQtwifiResultsList(JNIEnv *env, jclass thiz, jobject wifilist)
{
QList<WifiInfoBean> tempList;
//class ArrayList
jclass cls_arraylist = env->GetObjectClass(wifilist);
//method in class ArrayList
jmethodID arraylist_get = env->GetMethodID(cls_arraylist,"get","(I)Ljava/lang/Object;");
jmethodID arraylist_size = env->GetMethodID(cls_arraylist,"size","()I");
jint len = env->CallIntMethod(wifilist,arraylist_size);
// LOGE("len=%d\n",len);
// printf("get java ArrayList<WifiBean> object by C++ , then print it...../n");
for(int i=0;i<len;i++){
jobject obj_wifibean = env->CallObjectMethod(wifilist,arraylist_get,i);
jclass cls_wifibean = env->GetObjectClass(obj_wifibean);
jmethodID wifibean_wifiName = env->GetMethodID(cls_wifibean,"getWifiName","()Ljava/lang/String;");
jmethodID wifibean_macAddress = env->GetMethodID(cls_wifibean,"getMacAddress","()Ljava/lang/String;");
jmethodID wifibean_level = env->GetMethodID(cls_wifibean,"getLevel","()Ljava/lang/String;");
jmethodID wifibean_state = env->GetMethodID(cls_wifibean,"getState","()Ljava/lang/String;");
jmethodID wifibean_capabilities = env->GetMethodID(cls_wifibean,"getCapabilities","()Ljava/lang/String;");
jstring ssid = (jstring)env->CallObjectMethod(obj_wifibean,wifibean_wifiName);
jstring bssid = (jstring)env->CallObjectMethod(obj_wifibean,wifibean_macAddress);
jstring level = (jstring)env->CallObjectMethod(obj_wifibean,wifibean_level);
jstring state = (jstring)env->CallObjectMethod(obj_wifibean,wifibean_state);
jstring capabilities = (jstring)env->CallObjectMethod(obj_wifibean,wifibean_capabilities);
const char *c_ssid = env->GetStringUTFChars(ssid,0);
const char *c_bssid = env->GetStringUTFChars(bssid,0);
const char *c_level = env->GetStringUTFChars(level,0);
const char *c_state = env->GetStringUTFChars(state,0);
const char *c_capabilities = env->GetStringUTFChars(capabilities,0);
// LOGE("c_ssid=%s c_bssid=%s1 c_level=%s2 c_state=%s3 c_capabilities=%s4" ,c_ssid,c_bssid,c_level,c_state,c_capabilities);
WifiInfoBean *info=new WifiInfoBean();
info->SSID =QString(c_ssid);
info->BSSID=QString(c_bssid);
info->level=QString(c_level);
info->state =QString(c_state);
info->keytype=QString(c_capabilities);
tempList.append(*info);
//释放结构体
delete info;
env->ReleaseStringUTFChars(ssid,c_ssid);
env->ReleaseStringUTFChars(bssid,c_bssid);
env->ReleaseStringUTFChars(level,c_level);
env->ReleaseStringUTFChars(state,c_state);
env->ReleaseStringUTFChars(capabilities,c_capabilities);
//释放jmethodID
env->DeleteLocalRef(cls_wifibean);
env->DeleteLocalRef(obj_wifibean);
}
Interface::getInstance()->getWifiScanResultsList( tempList);
tempList.clear();
env->DeleteLocalRef(cls_arraylist);
}
/**
getQtwifiResultsList java传ArrayList泛型对象参数 给C++
* @brief Interface::getWifiScanResultsList
* @param list
* @return
*/
void Interface::getWifiScanResultsList( QList<WifiInfoBean> mlist)
{
if(mlist.size()!=0 && !mlist.isEmpty()){
wifiList.clear();
wifiList.append(mlist);
GetWifiObjectList();
}
}
QList<WifiInfoBean> Interface::GetWifiObjectList()
{
return wifiList;
}
/**
连接wifi
* @brief Interface::connectQtWifi
* @param position
* @param SSID
* @param PWD
*/
void Interface::connectQtWifi(QString capabilities,QString SSID ,QString PWD)
//void Interface::connectQtWifi(qint32 position, QString SSID ,QString PWD)
{
#ifdef Q_OS_ANDROID
QAndroidJniEnvironment env;
QAndroidJniObject m_activity = QtAndroid::androidActivity();
QAndroidJniObject jcapabilities = QAndroidJniObject::fromString(capabilities);
jstring string_java_capabilities = static_cast<jstring>(jcapabilities.object());
QAndroidJniObject jssid = QAndroidJniObject::fromString(SSID);
jstring string_java_wifiname = static_cast<jstring>(jssid.object());
QAndroidJniObject jpwd = QAndroidJniObject::fromString(PWD);
jstring string_java_password = static_cast<jstring>(jpwd.object());
QAndroidJniObject jmethod = m_activity.callObjectMethod("connectWifi", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",string_java_capabilities,string_java_wifiname,string_java_password);
jobject jobj = jmethod.object();
//将 jobject 类型强转成 jstring 类型 , 这两个都代表了 Java 的数据类型
jstring javaStr = static_cast<jstring>(jobj);
const char *c_str = env->GetStringUTFChars(javaStr, 0);
//释放资源
env->ReleaseStringUTFChars(javaStr,c_str);
env->DeleteLocalRef(jobj);
env->DeleteLocalRef(jmethod.object());
env->DeleteLocalRef(string_java_capabilities);
env->DeleteLocalRef(string_java_wifiname);
env->DeleteLocalRef(string_java_password);
if(env->ExceptionCheck()){
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
/**
断开连接
* @brief Interface::disConnectionQtWifi
* @param position
*/
void Interface::disConnectionQtWifi(QString ssid)
{
#ifdef Q_OS_ANDROID
QAndroidJniEnvironment env;
QAndroidJniObject m_activity = QtAndroid::androidActivity();
QAndroidJniObject jssid = QAndroidJniObject::fromString(ssid);
//将 jobject 类型强转成 jstring 类型 , 这两个都代表了 Java 的数据类型
jstring string_java_ssid = static_cast<jstring>(jssid.object());
QAndroidJniObject disconnectObject = m_activity.callObjectMethod("disconnectWifi", "(Ljava/lang/String;)Ljava/lang/String;",string_java_ssid);
jobject jdisconnect = disconnectObject.object();
//将 jobject 类型强转成 jstring 类型 , 这两个都代表了 Java 的数据类型
jstring java_disconnect_str = static_cast<jstring>(jdisconnect);
const char *c_disconnect_str = env->GetStringUTFChars(java_disconnect_str, 0);
//释放jstring
env->ReleaseStringUTFChars(java_disconnect_str,c_disconnect_str);
env->DeleteLocalRef(jdisconnect);
env->DeleteLocalRef(disconnectObject.object());
env->DeleteLocalRef(string_java_ssid);
if(env->ExceptionCheck()){
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
/**
删除取消保存
* @brief Interface::removeQtWifi
* @param ssid
*/
void Interface::removeQtWifi(QString ssid)
{
#ifdef Q_OS_ANDROID
QAndroidJniEnvironment env;
QAndroidJniObject m_activity = QtAndroid::androidActivity();
QAndroidJniObject jssid = QAndroidJniObject::fromString(ssid);
jstring string_java_remove_ssid = static_cast<jstring>(jssid.object());
QAndroidJniObject jremove = m_activity.callObjectMethod("removeWifi", "(Ljava/lang/String;)Ljava/lang/String;",string_java_remove_ssid);
const char *remove_str = env->GetStringUTFChars(string_java_remove_ssid, 0);
//释放jstring
env->ReleaseStringUTFChars(string_java_remove_ssid,remove_str);
env->DeleteLocalRef(string_java_remove_ssid);
env->DeleteLocalRef(jremove.object());
if(env->ExceptionCheck()){
env->ExceptionDescribe();
env->ExceptionClear();
}
#endif
}
main.cpp 中初始化
int main(int argc, char *argv[])
{
#ifdef Q_OS_ANDROID
bool success = Interface::getInstance()->registerNativeMethods();
if(success){
qDebug()<<"jason"<<"注册成功"<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
Interface::getInstance()->getQtRegisterJavaCode("1");
} else{
qDebug()<<"jason"<<"注册失败"<<QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz");
Interface::getInstance()->getQtRegisterJavaCode("0");
}
#endif
}
如果对你有帮助记得点赞！
1385
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
