uni wifi 適配自動化測試

pages/index/index.vue

@@ -41,9 +41,9 @@
 			testConnnectWifi(){
 
 				uni.connectWifi({
-					maunal:false,
+					maunal:true,
 					SSID:"Xiaomi_20D0",
-					password:"BBBB",
+					password:"BBB111",
 					complete:(res)=>{
 						console.log(res);
 					}

uni_modules/uni-wifi/utssdk/app-android/index.uts

@@ -17,68 +17,72 @@ import AuthAlgorithm from 'android.net.wifi.WifiConfiguration.AuthAlgorithm';
 import KeyMgmt from 'android.net.wifi.WifiConfiguration.KeyMgmt';
 import TextUtils from 'android.text.TextUtils';
 
-/**
- * Wifi 函数通用入参封装
- */
-type WifiOption = {
-	success?: (res: object) => void;
-	fail?: (res: object) => void;
-	complete?: (res: object) => void;
-};
-
-
-/**
- * 获取当前链接的wifi信息
- */
-type GetConnectedWifiOptions = {
-	partialInfo?: boolean
-	success?: (res: UTSJSONObject) => void
-	fail?: (res: UTSJSONObject) => void
-	complete?: (res: UTSJSONObject) => void
-}
-
-/**
- * Wifi 链接参数封装
- */
-type WifiConnectOption = {
-	SSID:string;
-	BSSID?:string;
-	password:string;
-	maunal:boolean;
-	// 只返回ssid
-	partialInfo:boolean;
-	success?: (res: object) => void;
-	fail?: (res: object) => void;
-	complete?: (res: object) => void;
-}
+import { UniWifiResult, GetConnectedWifiOptions, WifiConnectOption, WifiOption, UniWifiInfo,UniWifiPartialInfo, UniWifiCallback, StartWifi, StopWifi, GetWifiList, GetConnectedWifi, OnGetWifiList, OnWifiConnectedWithPartialInfo, OnOffWifiConnectedWithPartialInfo, OnWifiConnected, ConnectWifi, OffGetWifiList, OffWifiConnected, SetWifiList } from "../interface.uts"
+
+
+
+// /**
+//  * Wifi 函数通用入参封装
+//  */
+// type WifiOption = {
+// 	success?: (res: object) => void;
+// 	fail?: (res: object) => void;
+// 	complete?: (res: object) => void;
+// };
+
+
+// /**
+//  * 获取当前链接的wifi信息
+//  */
+// type GetConnectedWifiOptions = {
+// 	partialInfo?: boolean
+// 	success?: (res: UTSJSONObject) => void
+// 	fail?: (res: UTSJSONObject) => void
+// 	complete?: (res: UTSJSONObject) => void
+// }
+
+// /**
+//  * Wifi 链接参数封装
+//  */
+// type WifiConnectOption = {
+// 	SSID:string;
+// 	BSSID?:string;
+// 	password:string;
+// 	maunal:boolean;
+// 	// 只返回ssid
+// 	partialInfo:boolean;
+// 	success?: (res: object) => void;
+// 	fail?: (res: object) => void;
+// 	complete?: (res: object) => void;
+// }
 
 
 
 /**
- * 全局数据储存
- */
+	* 全局数据储存
+	*/
 class Global {
-	static mReceiver: CustomBroadcastReceiver|null = null;
-	static WIFI_AUTH_OPEN: string = "";
-	static WIFI_AUTH_ROAM: String = "[ESS]";
+	static mReceiver : CustomBroadcastReceiver | null = null;
+	static WIFI_AUTH_OPEN : string = "";
+	static WIFI_AUTH_ROAM : String = "[ESS]";
 	// 扫描wifi结果
-	static scanList: UniWifiInfo[] = []
+	static scanList : AndroidUniWifiInfo[] = []
 	// 获取wifi列表监听
-	static getWifiListCallbackList: UTSCallback[] = []
+	static getWifiListCallbackList : UTSCallback[] = []
 	// wifi链接监听
-	static onWifiConnectCallbackList: UTSCallback[] = []
-	static onWifiConnectWithPartialInfoCallbackList: UTSCallback[] = []
+	static onWifiConnectCallbackList : UTSCallback[] = []
+	static onWifiConnectWithPartialInfoCallbackList : UTSCallback[] = []
 }
 
 
 /**
- * 是否是标准的16进制字符
- */
-function isHex(key:string):boolean {
+	* 是否是标准的16进制字符
+	*/
+function isHex(key : string) : boolean {
 	for (var i = key.length - 1; i >= 0; i--) {
 		let c = key.charAt(i);
 		if (!(c >= '0' && c <= '9' || c >= 'A' && c <= 'F' || c >= 'a'
-				&& c <= 'f')) {
+			&& c <= 'f')) {
 			return false;
 		}
 	}
@@ -87,9 +91,9 @@ function isHex(key:string):boolean {
 }
 
 /**
- * 判断是否是wep格式的key
- */
-function isHexWepKey(wepKey:string):boolean {
+	* 判断是否是wep格式的key
+	*/
+function isHexWepKey(wepKey : string) : boolean {
 	let len = wepKey.length;
 
 	// WEP-40, WEP-104, and some vendors using 256-bit WEP (WEP-232?)
@@ -100,77 +104,157 @@ function isHexWepKey(wepKey:string):boolean {
 	return isHex(wepKey);
 }
 
+export type AndroidUniWifiInfo = {
+	SSID : string;
+	BSSID ?: string;
+	secure : boolean;
+	signalStrength : number;
+	frequency : number;
+	securityType : string;
+}
 
-/**
- * Wifi信息统一数据结构
- */
-class UniWifiInfo {
-
-	SSID: string = "";
-	BSSID: string = "";
-	secure: boolean = false;
-	signalStrength: Number = 0;
-	frequency: Number = 0;
-	
-	/*下面的字段属于扩展字段*/
-	securityType:string = ""
-
-	constructor(scanResult: ScanResult|null = null) {
-		if (scanResult != null) {
-			// 如果是通过扫描列表得到的数据，进行封装
-			this.BSSID = scanResult.BSSID;
-			this.SSID = scanResult.SSID;
-
-			this.signalStrength = scanResult.level;
-			this.frequency = scanResult.frequency;
-
-			// 是否安全，微信的标准是是否需要密码。 来源:https://developers.weixin.qq.com/community/develop/doc/00064cf1790458db19cddf9925ac00?highLine=WifiInfo
-			this.secure = false;
-			let capabilities = scanResult.capabilities.trim();
-			if ((capabilities.equals(Global.WIFI_AUTH_OPEN) || capabilities.equals(Global.WIFI_AUTH_ROAM))) {
-				this.secure = false;
-			} else {
-				this.secure = true;
-			}
-			
-			/*扩展字段*/
-			this.securityType = getSecurityType(scanResult);
-		}
+function wrapUniWifiInfoFromAndroid(androidInfo:AndroidUniWifiInfo): UniWifiInfo{
+	let ret : UniWifiInfo = {
+		SSID: androidInfo.SSID,
+		BSSID: androidInfo.BSSID,
+		secure: androidInfo.secure,
+		signalStrength: androidInfo.signalStrength,
+		frequency: androidInfo.frequency,
 	}
+	return ret
+}
 
-	/**
-	 * 根据connectInfo 链接信息对wifi数据结构进行初始化
-	 */
-	wrapConnectInfo(connectInfo: WifiInfo): void {
-		
-		if (connectInfo.getBSSID() == null) {
-			return
-		}
-		if (connectInfo.getSSID() != null) {
-			let s = connectInfo.getSSID();
-			// 微信不带，这里需要去掉引号
-			if (s.length > 2 && s.charAt(0) == '"' && s.charAt(s.length - 1) == '"') {
-				s = s.substring(1, s.length - 1);
-			}
-			this.SSID = s;
+function wrapUniWifiInfoFromScan(scanResult : ScanResult) : AndroidUniWifiInfo {
+
+	let ret : AndroidUniWifiInfo = {
+		SSID: "",
+		secure: false,
+		signalStrength: 0,
+		frequency: 0,
+		securityType:"NONE"
+	}
+	if (scanResult != null) {
+		// 如果是通过扫描列表得到的数据，进行封装
+		ret.BSSID = scanResult.BSSID;
+		ret.SSID = scanResult.SSID;
+
+		ret.signalStrength = scanResult.level;
+		ret.frequency = scanResult.frequency;
+
+		// 是否安全，微信的标准是是否需要密码。 来源:https://developers.weixin.qq.com/community/develop/doc/00064cf1790458db19cddf9925ac00?highLine=WifiInfo
+		ret.secure = false;
+		let capabilities = scanResult.capabilities.trim();
+		if ((capabilities.equals(Global.WIFI_AUTH_OPEN) || capabilities.equals(Global.WIFI_AUTH_ROAM))) {
+			ret.secure = false;
+		} else {
+			ret.secure = true;
 		}
-			
-			this.BSSID = connectInfo.getBSSID();
-			//Android返回的值是-100~0，而微信API规范是0~100，值越大信号越好，需要+100拉齐
-			this.signalStrength = connectInfo.getRssi() + 100; 
-			this.frequency = connectInfo.getFrequency();
-		
+
+		/*扩展字段*/
+		ret.securityType = getSecurityType(scanResult);
+	}
+
+	return ret
+}
+
+function wrapUniWifiInfoFromConnectInfo(connectInfo : WifiInfo) : UniWifiInfo {
+	let ret : UniWifiInfo = {
+		SSID: "",
+		secure: false,
+		signalStrength: 0,
+		frequency: 0,
 	}
 	
 	
+	if (connectInfo.getSSID() != null) {
+		let s = connectInfo.getSSID();
+		// 微信不带，这里需要去掉引号
+		if (s.length > 2 && s.charAt(0) == '"' && s.charAt(s.length - 1) == '"') {
+			s = s.substring(1, s.length - 1);
+		}
+		ret.SSID = s;
+	}
+
+	ret.BSSID = connectInfo.getBSSID();
+	//Android返回的值是-100~0，而微信API规范是0~100，值越大信号越好，需要+100拉齐
+	ret.signalStrength = connectInfo.getRssi() + 100;
+	ret.frequency = connectInfo.getFrequency();
+
+
+	return ret
 }
 
+
+// /**
+//  * Wifi信息统一数据结构
+//  */
+// class UniWifiInfo {
+
+// 	SSID: string = "";
+// 	BSSID: string = "";
+// 	secure: boolean = false;
+// 	signalStrength: Number = 0;
+// 	frequency: Number = 0;
+
+// 	/*下面的字段属于扩展字段*/
+// 	securityType:string = ""
+
+// 	constructor(scanResult: ScanResult|null = null) {
+// 		if (scanResult != null) {
+// 			// 如果是通过扫描列表得到的数据，进行封装
+// 			this.BSSID = scanResult.BSSID;
+// 			this.SSID = scanResult.SSID;
+
+// 			this.signalStrength = scanResult.level;
+// 			this.frequency = scanResult.frequency;
+
+// 			// 是否安全，微信的标准是是否需要密码。 来源:https://developers.weixin.qq.com/community/develop/doc/00064cf1790458db19cddf9925ac00?highLine=WifiInfo
+// 			this.secure = false;
+// 			let capabilities = scanResult.capabilities.trim();
+// 			if ((capabilities.equals(Global.WIFI_AUTH_OPEN) || capabilities.equals(Global.WIFI_AUTH_ROAM))) {
+// 				this.secure = false;
+// 			} else {
+// 				this.secure = true;
+// 			}
+
+// 			/*扩展字段*/
+// 			this.securityType = getSecurityType(scanResult);
+// 		}
+// 	}
+
+// 	/**
+// 	 * 根据connectInfo 链接信息对wifi数据结构进行初始化
+// 	 */
+// 	wrapConnectInfo(connectInfo: WifiInfo): void {
+
+// 		if (connectInfo.getBSSID() == null) {
+// 			return
+// 		}
+// 		if (connectInfo.getSSID() != null) {
+// 			let s = connectInfo.getSSID();
+// 			// 微信不带，这里需要去掉引号
+// 			if (s.length > 2 && s.charAt(0) == '"' && s.charAt(s.length - 1) == '"') {
+// 				s = s.substring(1, s.length - 1);
+// 			}
+// 			this.SSID = s;
+// 		}
+
+// 			this.BSSID = connectInfo.getBSSID();
+// 			//Android返回的值是-100~0，而微信API规范是0~100，值越大信号越好，需要+100拉齐
+// 			this.signalStrength = connectInfo.getRssi() + 100; 
+// 			this.frequency = connectInfo.getFrequency();
+
+// 	}
+
+
+// }
+
 /**
- * 连接wifi时使用，根据用户输入内容包装为系统需要的wifi配置对象
- */
+	* 连接wifi时使用，根据用户输入内容包装为系统需要的wifi配置对象
+	*/
 @Suppress("DEPRECATION")
-function wrapWifiConfiguration(SSID:string ,password:string,passwordType:string):WifiConfiguration {
-		
+function wrapWifiConfiguration(SSID : string, password ?: string, passwordType : string) : WifiConfiguration {
+
 	let config = new WifiConfiguration();
 	config.status = WifiConfiguration.Status.ENABLED;
 	config.allowedAuthAlgorithms.clear();
@@ -179,15 +263,15 @@ function wrapWifiConfiguration(SSID:string ,password:string,passwordType:string)
 	config.allowedPairwiseCiphers.clear();
 	config.allowedProtocols.clear();
 	config.SSID = "\"".concat(SSID).concat("\"");
-	
-	
+
+
 	// nopass
-	if ("NONE".equals(passwordType)) {
+	if ("NONE".equals(passwordType) || password == null) {
 		config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
 	}
 	// wep
-	if ("WEP".equals(passwordType)) {
-		if (!TextUtils.isEmpty(password)) {
+	else if ("WEP".equals(passwordType)) {
+		if (password != null && !TextUtils.isEmpty(password)) {
 			if (isHexWepKey(password)) {
 				config.wepKeys[0] = password;
 			} else {
@@ -200,7 +284,7 @@ function wrapWifiConfiguration(SSID:string ,password:string,passwordType:string)
 		config.wepTxKeyIndex = 0;
 	}
 	// wpa
-	if ("WPA".equals(passwordType)) {
+	else if ("WPA".equals(passwordType)) {
 		config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
 		config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
 		config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
@@ -212,50 +296,53 @@ function wrapWifiConfiguration(SSID:string ,password:string,passwordType:string)
 		config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
 		config.preSharedKey = "\"".concat(password).concat("\"");
 	}
-	
+
 	return config;
 }
 
 
 /**
- * 判断当前wifi的加密类型
- */
-function getSecurityType(result:ScanResult):string {
-    if (result.capabilities.contains("WEP")) {
-        return "WEP";
-    } else if (result.capabilities.contains("PSK")) {
-        return "WPA";
-    } else if (result.capabilities.contains("EAP")) {
-        return "EAP";
-    }
-    return "NONE";
+	* 判断当前wifi的加密类型
+	*/
+function getSecurityType(result : ScanResult) : string {
+	if (result.capabilities.contains("WEP")) {
+		return "WEP";
+	} else if (result.capabilities.contains("PSK")) {
+		return "WPA";
+	} else if (result.capabilities.contains("EAP")) {
+		return "EAP";
+	}
+	return "NONE";
 }
 
 
-function zeroCountNum(source:string):number{
+function zeroCountNum(source? : string) : number {
+	if(source == null){
+		return 0
+	}
 	var splitted = source.split(":")
 	var countNum = 0;
-	for(perItem in splitted){
-		if(perItem == "00"){
+	for (perItem in splitted) {
+		if (perItem == "00") {
 			countNum += 1
 		}
 	}
 	return countNum
 }
 /**
- * 自定义wifi变化广播监听器
- */
-@Suppress("UNUSED_PARAMETER","DEPRECATION")
+	* 自定义wifi变化广播监听器
+	*/
+@Suppress("UNUSED_PARAMETER", "DEPRECATION")
 class CustomBroadcastReceiver extends BroadcastReceiver {
 
-	mWifiManager: WifiManager|null = null;
+	mWifiManager : WifiManager | null = null;
 
-	constructor(wifiManager: WifiManager) {
+	constructor(wifiManager : WifiManager) {
 		super();
 		this.mWifiManager = wifiManager;
 	}
 
-	override onReceive(_context: Context, intent: Intent): void {
+	override onReceive(_context : Context, intent : Intent) : void {
 
 
 		if (intent.action == WifiManager.WIFI_STATE_CHANGED_ACTION) {
@@ -263,20 +350,26 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 				intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN)
 			if (state == WifiManager.WIFI_STATE_ENABLED) {
 				// 获取当前的connectInfo 并且进行数据封装
-				let uniWifiInfo = new UniWifiInfo(null)
+				// let uniWifiInfo = new UniWifiInfo(null)
+				let uniWifiInfo : UniWifiInfo = {
+					SSID: "",
+					secure: false,
+					signalStrength: 0,
+					frequency: 0,
+				}
 				//做一些异步操作
-				setTimeout(function() {
+				setTimeout(function () {
 					// BroadcastReceiver 中不能执行耗时任务，需要使用setTimeout
 					// @ts-ignore
 					let winfo = this.mWifiManager!.getConnectionInfo();
-					
+
 					while (winfo.bssid == null || zeroCountNum(winfo.bssid) > 4) {
 						Thread.sleep(1000)
 						winfo = this.mWifiManager!.getConnectionInfo();
 					}
 
 					// 封装成数据对象
-					uniWifiInfo.wrapConnectInfo(winfo)
+					uniWifiInfo = wrapUniWifiInfoFromConnectInfo(winfo)
 					let res = {
 						errMsg: 'onWifiConnected:ok',
 						errCode: 0,
@@ -288,7 +381,7 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 					}
 					// 封装仅SSID 数据对象
 					var connectedWithPartialInfo = {
-						SSID:uniWifiInfo.SSID
+						SSID: uniWifiInfo.SSID
 					}
 					for (let perCallback in Global.onWifiConnectWithPartialInfoCallbackList) {
 						perCallback(connectedWithPartialInfo);
@@ -310,7 +403,7 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 					if (scanResult.SSID == null) {
 						continue;
 					}
-					Global.scanList.push(new UniWifiInfo(scanResult));
+					Global.scanList.push(wrapUniWifiInfoFromScan(scanResult));
 				}
 
 				// 挨个通知，所有的监听器
@@ -334,18 +427,18 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 /************************* 下面是对外提供的函数 *************************/
 
 /**
- * 开启wifi
- */
+	* 开启wifi
+	*/
 @Suppress("DEPRECATION")
-export function startWifi(option: WifiOption) {
-	
+export function startWifi(option : WifiOption) {
+
 	// 需要先开启wifi,才能使用后续的功能
 	let requestCode = 1001;
 	let permissionWifi = arrayOf("android.permission.ACCESS_FINE_LOCATION");
-	var result = {
+	var result : UniWifiResult = {
 		errCode: 12001,
 		errMsg: "startWifi:premission loss",
-		errSubject:"uni-startWifi"
+		errSubject: "uni-startWifi"
 	}
 	// 检查权限
 	if (ActivityCompat.checkSelfPermission(UTSAndroid.getUniActivity()!, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
@@ -359,14 +452,14 @@ export function startWifi(option: WifiOption) {
 	}
 
 	// 具备了权限，继续前进
-	let wifiManager: WifiManager =
+	let wifiManager : WifiManager =
 		UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
 	// 用户没有开启wifi 总开关
-	if(!wifiManager.isWifiEnabled()){
+	if (!wifiManager.isWifiEnabled()) {
 		// wifi 没开启
 		result.errCode = 12005;
 		result.errMsg = "wifi not turned on";
-		
+
 		option.fail?.(result);
 		option.complete?.(result);
 		return;
@@ -382,63 +475,64 @@ export function startWifi(option: WifiOption) {
 	filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION)
 	// @ts-ignore
 	filter.addAction(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
-	
+
 	UTSAndroid.getUniActivity()!.registerReceiver(Global.mReceiver, filter)
-	
+
 	/**
-	 * activity 被销毁时，取消注册
-	 */
-	UTSAndroid.onAppActivityDestroy(function(){
-		
-		if(Global.mReceiver!= null){
+		* activity 被销毁时，取消注册
+		*/
+	UTSAndroid.onAppActivityDestroy(function () {
+
+		if (Global.mReceiver != null) {
 			UTSAndroid.getUniActivity()!.unregisterReceiver(Global.mReceiver)
 			Global.mReceiver = null
-			
+
 			Global.scanList = []
 			Global.getWifiListCallbackList = []
 			Global.onWifiConnectCallbackList = []
 			Global.onWifiConnectWithPartialInfoCallbackList = []
 		}
-		
+
 	});
 	// 开始扫描
 	wifiManager.startScan()
-	
+
 	result.errCode = 0
 	result.errMsg = "startWifi:ok"
-	
+
 	option.success?.(result)
 	option.complete?.(result)
 
 }
 
 /**
- * 获取wifi列表
- */
+	* 获取wifi列表
+	*/
 @Suppress("DEPRECATION")
-export function getWifiList(option: WifiOption) {
-	
-	var result = {
+export function getWifiList(option : WifiOption) {
+
+	var result : UniWifiResult = {
 		errCode: 12000,
 		errMsg: "getWifiList:fail:not invoke startWifi",
-		errSubject:"uni-getWifiList"
+		errSubject: "uni-getWifiList"
 	}
-	
+
 	if (Global.mReceiver == null) {
 		// 还没调用startWifi 提示报错
 		option.fail?.(result)
 		option.complete?.(result)
-	
+
 		return
 	}
-	
-	let wifiManager: WifiManager =
+
+	let wifiManager : WifiManager =
 		UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
-	
+
 	wifiManager.startScan()
 
-	let ret = {
+	let ret : UniWifiResult = {
 		errCode: 0,
+		errSubject: "uni-getWifiList",
 		errMsg: "getWifiList:ok"
 	}
 	option.success?.(ret)
@@ -449,29 +543,29 @@ export function getWifiList(option: WifiOption) {
 
 
 /**
- * wifi 链接成功的回调注册
- */
-export function onWifiConnected(callback: UTSCallback) {
+	* wifi 链接成功的回调注册
+	*/
+export function onWifiConnected(callback : UTSCallback) {
 	Global.onWifiConnectCallbackList.push(callback)
 }
 
 
-export function onWifiConnectedWithPartialInfo(callback: UTSCallback) {
+export function onWifiConnectedWithPartialInfo(callback : UTSCallback) {
 	Global.onWifiConnectWithPartialInfoCallbackList.push(callback)
 }
 
 
 /**
- * wifi 链接成功的回调取消注册
- */
-export function offWifiConnected(callback: UTSCallback) {
+	* wifi 链接成功的回调取消注册
+	*/
+export function offWifiConnected(callback : UTSCallback) {
 	let callbackIndex = Global.onWifiConnectCallbackList.indexOf(callback)
 	if (callbackIndex > 0) {
 		Global.onWifiConnectCallbackList.splice(callbackIndex, 1);
 	}
 }
 
-export function offWifiConnectedWithPartialInfo(callback: UTSCallback) {
+export function offWifiConnectedWithPartialInfo(callback : UTSCallback) {
 	let callbackIndex = Global.onWifiConnectWithPartialInfoCallbackList.indexOf(callback)
 	if (callbackIndex > 0) {
 		Global.onWifiConnectWithPartialInfoCallbackList.splice(callbackIndex, 1);
@@ -479,15 +573,15 @@ export function offWifiConnectedWithPartialInfo(callback: UTSCallback) {
 }
 
 /**
- * 注册Wifi列表的监听事件
- */
-export function onGetWifiList(callback: UTSCallback) {
+	* 注册Wifi列表的监听事件
+	*/
+export function onGetWifiList(callback : UTSCallback) {
 	Global.getWifiListCallbackList.push(callback)
 }
 /**
- * 取消注册Wifi列表的监听事件
- */
-export function offGetWifiList(callback: UTSCallback) {
+	* 取消注册Wifi列表的监听事件
+	*/
+export function offGetWifiList(callback : UTSCallback) {
 	let callbackIndex = Global.getWifiListCallbackList.indexOf(callback)
 	if (callbackIndex > 0) {
 		Global.getWifiListCallbackList.splice(callbackIndex, 1);
@@ -496,62 +590,61 @@ export function offGetWifiList(callback: UTSCallback) {
 
 
 /**
- * 链接指定wifi
- */
-@Suppress("UNUSED_PARAMETER","DEPRECATION")
-export function connectWifi(option: WifiConnectOption) {
-	
+	* 链接指定wifi
+	*/
+@Suppress("UNUSED_PARAMETER", "DEPRECATION")
+export function connectWifi(option : WifiConnectOption) {
 
-	var result = {
+
+	var result : UniWifiResult = {
 		errCode: 12000,
 		errMsg: "connectWifi:fail:not invoke startWifi",
-		errSubject:"uni-connectWifi",
+		errSubject: "uni-connectWifi",
 	}
-	
+
 	if (Global.mReceiver == null || Global.scanList.length < 1) {
 		// 还没调用startWifi 提示报错
 		option.fail?.(result)
 		option.complete?.(result)
-	
+
 		return
 	}
-	
-	if(option.maunal == true){
+
+	if (option.maunal == true) {
 		// 指定了手动模式
 		let manunalIntent = new Intent(android.provider.Settings.ACTION_WIFI_SETTINGS);
 		UTSAndroid.getUniActivity()!.startActivity(manunalIntent);
-		
+
 		result.errCode = 0
 		result.errMsg = "connectWifi:ok"
-		
+
 		option.success?.(result)
 		option.complete?.(result)
-		return 
+		return
 	}
-	
+
 	// 执行后续的逻辑
-	let scanWifiInfo:UniWifiInfo|null = null
+	let scanWifiInfo : AndroidUniWifiInfo | null = null
 	for (let scanResult in Global.scanList) {
-		
 		if (scanResult.SSID.equals(option.SSID)) {
 			scanWifiInfo = scanResult
 		}
 	}
-	
-	if(scanWifiInfo == null){
+
+	if (scanWifiInfo == null) {
 		// 不在扫描列表中返回错误
 		option.fail?.(result)
 		option.complete?.(result)
 		return
 	}
-	
-	let wifiConfigration = wrapWifiConfiguration(scanWifiInfo.SSID,option.password,scanWifiInfo.securityType);
+
+	let wifiConfigration = wrapWifiConfiguration(scanWifiInfo.SSID, option.password, scanWifiInfo.securityType);
 	wifiConfigration.BSSID = scanWifiInfo.BSSID
-	let wifiManager: WifiManager =
+	let wifiManager : WifiManager =
 		UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
-	
+
 	// 如果已经存在了指定wifi 配置，移除之
-	let targetExistConfig:WifiConfiguration|null = null
+	let targetExistConfig : WifiConfiguration | null = null
 	let existingConfigs = wifiManager.getConfiguredNetworks();
 	for (let existingConfig in existingConfigs) {
 		if (existingConfig.SSID.equals("\"" + option.SSID + "\"")) {
@@ -560,104 +653,104 @@ export function connectWifi(option: WifiConnectOption) {
 	}
 	// 如果wifi已经保存了当前ssid的配置，可能是别的应用添加的。android系统要求，需要删除掉重新添加
 	if (targetExistConfig != null) {
-		console.log("targetExistConfig.networkId  === " + targetExistConfig.networkId);
 		let removeRet = wifiManager.removeNetwork(targetExistConfig.networkId);
-		
-		if(!removeRet){
+
+		if (!removeRet) {
 			// 移除之前的配置失败了，返回错误，需要用户手动取消保存一下
 			result.errCode = 12013
 			result.errMsg = "connectWifi:wifi config may be expired"
-			
+
 			option.fail?.(result)
 			option.complete?.(result)
-			
+
 			return
 		}
-		
+
 	}
-	
+
 	let currentConnect = wifiManager.getConnectionInfo()
-	if(currentConnect.networkId >= 0){
-	    wifiManager.disableNetwork(currentConnect.networkId)
-	}else{
+	if (currentConnect.networkId >= 0) {
+		wifiManager.disableNetwork(currentConnect.networkId)
+	} else {
 		wifiManager.removeNetwork(currentConnect.networkId)
 	}
 	wifiManager.disconnect()
-	
+
 	let connected = false;
 	try {
-		
+
 		let netID = wifiManager.addNetwork(wifiConfigration);
 		// 如果-1 说明没添加上，报错即可
-		if(netID < 0){
+		if (netID < 0) {
 			result.errCode = 12002
 			result.errMsg = "connectWifi:password error Wi-Fi"
 
 			option.fail?.(result)
 			option.complete?.(result)
-			
+
 			return
 		}
-		
-	
+
+
 		let enabled = wifiManager.enableNetwork(netID, true);
-		if(!enabled){
-		
+		if (!enabled) {
+
 			result.errCode = 12007
 			result.errMsg = "connectWifi:user denied"
-			
+
 			option.fail?.(result)
 			option.complete?.(result)
-			
+
 			return
 		}
 		connected = wifiManager.reconnect();
-		
+
 	} catch (e) {
 		connected = false;
 		console.log(e);
 	}
-	
-	if(!connected){
+
+	if (!connected) {
 		// 出错了，返回错误
 		// 兜底的报错
 		result.errCode = 12010
 		result.errMsg = "connectWifi:fail:unknown error"
-		
+
 		option.fail?.(result)
 		option.complete?.(result)
-		return 
+		return
 	}
-	
+
 	wifiManager.saveConfiguration()
 	//scanWifiInfo 根据 partialInfo 填充给返回字段
-	if(option.partialInfo){
-		result['wifi'] = {
-			SSID:scanWifiInfo.SSID
+	if (option.partialInfo != null && option.partialInfo == true) {
+		let wifiPartialInfo:UniWifiInfo = {
+			SSID: scanWifiInfo.SSID
 		}
-	}else{
-		result['wifi'] = scanWifiInfo
+		result.wifi =wifiPartialInfo
+	} else {
+		result.wifi = wrapUniWifiInfoFromAndroid(scanWifiInfo)
 	}
-	
+
 	// result.wifi = scanWifiInfo.toUTSJSON(option.partialInfo)
 	result.errCode = 0
 	result.errMsg = "connectWifi:ok"
-	
+
 	option.success?.(result)
 	option.complete?.(result)
-	
+
 }
 
 
 /**
- * 关闭wifi
- */
-export function stopWifi(option: WifiOption) {
+	* 关闭wifi
+	*/
+export function stopWifi(option : WifiOption) {
 	// 需要先开启wifi,才能使用后续的功能
 	if (Global.mReceiver == null) {
-		var result = {
-			errNo: 12000,
+		var result:UniWifiResult = {
 			errCode: 12000,
+			errSubject:"uni-stopWifi",
 			errMsg: "stopWifi:not init"
 		}
 		option.fail?.(result)
@@ -665,16 +758,16 @@ export function stopWifi(option: WifiOption) {
 
 		return
 	}
-	try{
+	try {
 		UTSAndroid.getUniActivity()!.unregisterReceiver(Global.mReceiver)
-	}catch(e){
+	} catch (e) {
 		// 多次调用
 		//TODO handle the exception
 	}
-	
-	var result = {
-		errNo: 0,
+
+	var result:UniWifiResult = {
 		errCode: 0,
+		errSubject:"uni-stopWifi",
 		errMsg: "stopWifi:ok"
 	}
 	option.success?.(result)
@@ -683,32 +776,34 @@ export function stopWifi(option: WifiOption) {
 }
 
 /**
- * 获取当前连接中的wifi信息
- */
+	* 获取当前连接中的wifi信息
+	*/
 @Suppress("DEPRECATION")
-export function getConnectedWifi(option: GetConnectedWifiOptions) {
+export function getConnectedWifi(option : GetConnectedWifiOptions) {
 
-	let wifiInfo = new UniWifiInfo(null)
+	let wifiInfo:UniWifiInfo = {
+		SSID:""
+	}
 
-	var res = {
+	var res:UniWifiResult = {
 		errCode: 12000,
 		errMsg: "getConnectedWifi:fail:not invoke startWifi",
-		errSubject:"uni-getConnectedWifi",
+		errSubject: "uni-getConnectedWifi",
 	}
 
 	if (Global.mReceiver == null) {
 		// 还没调用startWifi 提示报错
 		option.fail?.(res)
 		option.complete?.(res)
-	
+
 		return
 	}
-	
+
 	if (ActivityCompat.checkSelfPermission(UTSAndroid.getUniActivity()!, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
 		// 尚不具备权限，返回错误
 		res.errCode = 12001
 		res.errMsg = "getConnectedWifi:permission loss"
-		
+
 		option.fail?.(res)
 		option.complete?.(res)
 		return;
@@ -724,31 +819,29 @@ export function getConnectedWifi(option: GetConnectedWifiOptions) {
 		// 测试android 12上可以使用
 		//@ts-ignore
 		const winfo = wm.getConnectionInfo();
-		
-		
-		console.log("option.partialInfo  === " + option.partialInfo);
-		wifiInfo.wrapConnectInfo(winfo);
+
+		wifiInfo = wrapUniWifiInfoFromConnectInfo(winfo);
 		// 判断一下是否wifi 关闭了
-		if(option.partialInfo!){
-			let ret = {
-				SSID : wifiInfo.SSID
+		if (option.partialInfo!) {
+			let ret:UniWifiInfo = {
+				SSID: wifiInfo.SSID
 			}
-			res['wifi'] = ret;
-		}else{
-			if(wifiInfo.BSSID == null || zeroCountNum(wifiInfo.BSSID) > 3){
+			res.wifi = ret;
+		} else {
+			if (wifiInfo.BSSID == null || zeroCountNum(wifiInfo.BSSID) > 3) {
 				res.errCode = 12005
 				res.errMsg = "getConnectedWifi:fail:wifi is disable"
-				
+
 				option.fail?.(res)
 				option.complete?.(res)
 				return
 			}
-			res['wifi'] = wifiInfo;
+			res.wifi = wifiInfo;
 		}
-		
+
 		res.errCode = 0
 		res.errMsg = "getConnectedWifi:ok"
-		
+
 		option.success?.(res)
 		option.complete?.(res)
 		return

uni_modules/uni-wifi/utssdk/interface.uts

+/**
+ * Wifi 函数通用入参封装
+ */
+ export type WifiOption = {
+	success?: (res: UniWifiResult) => void;
+	fail?: (res: UniWifiResult) => void;
+	complete?: (res: UniWifiResult) => void;
+};
+
+/**
+ * Wifi 链接参数封装 
+ */
+export type WifiConnectOption = {
+	SSID?: string;
+	BSSID?: string;
+	password?: string;
+	maunal?: boolean;
+	partialInfo?: boolean; //ios不生效
+	success?: (res: UniWifiResult) => void;
+	fail?: (res: UniWifiResult) => void;
+	complete?: (res: UniWifiResult) => void;
+}
+
+/**
+ * 获取当前链接的wifi信息
+ */
+export type GetConnectedWifiOptions = {
+	partialInfo?: boolean
+	success?: (res: UniWifiResult) => void
+	fail?: (res: UniWifiResult) => void
+	complete?: (res: UniWifiResult) => void
+}
+
+/* 
+ * 对外暴露的wifi信息
+ */
+export type UniWifiInfo = {
+	SSID: string;
+	BSSID?: string;
+	secure?: boolean;
+	signalStrength?: number;
+	frequency?: number;
+}
+
+
+export type UniWifiResult = {
+	errCode : number,
+	errSubject : string,
+	errMsg : string,
+	wifi: UniWifiInfo | null
+}
+
+export type UniWifiCallback = () => void
+
+
+export type StartWifi = (option: WifiOption) => void
+
+export type StopWifi = (option: WifiOption) => void
+
+export type GetWifiList = (option: WifiOption) => void
+
+export type OnGetWifiList = (callback: UniWifiCallback) => void
+
+export type OffGetWifiList = (callback: UniWifiCallback) => void
+
+export type GetConnectedWifi = (option: GetConnectedWifiOptions) => void
+
+export type ConnectWifi = (option: WifiConnectOption) => void
+
+export type OnWifiConnected = (callback: UniWifiCallback) => void
+
+export type OnWifiConnectedWithPartialInfo = (callback: UniWifiCallback) => void
+
+export type OffWifiConnected = (callback: UniWifiCallback | null) => void
+
+export type OnOffWifiConnectedWithPartialInfo = (callback: UniWifiCallback | null) => void
+
+export type SetWifiList = (option: WifiOption) => void
+
+interface Uni {
+	startWifi : StartWifi,
+	stopWifi : StopWifi,
+	getWifiList : GetWifiList,
+	onGetWifiList : OnGetWifiList,
+	offGetWifiList : OffGetWifiList,
+	getConnectedWifi : GetConnectedWifi,
+	onWifiConnected : OnWifiConnected,
+	onWifiConnectedWithPartialInfo : OnWifiConnectedWithPartialInfo,
+	offWifiConnected : OffWifiConnected,
+	onOffWifiConnectedWithPartialInfo : OnOffWifiConnectedWithPartialInfo,
+	setWifiList : SetWifiList,
+}