Merge branch 'dev_autotest' into dev

jest.config.js

+module.exports = {
+    testTimeout: 10000,
+    reporters: [
+        'default'
+    ],
+    watchPathIgnorePatterns: ['/node_modules/', '/dist/', '/.git/'],
+    moduleFileExtensions: ['js', 'json'],
+    rootDir: __dirname,
+    testMatch: ["<rootDir>/pages/**/*test.[jt]s?(x)"],
+    testPathIgnorePatterns: ['/node_modules/']
+}

pages.json

@@ -5,7 +5,14 @@
 			"style": {
 				"navigationBarTitleText": "uni-app"
 			}
-		}
+        },
+        {
+            "path": "pages/autotest/uni-wifi/uni-wifi",
+            "style": {
+                "navigationBarTitleText": "uni-wifi",
+                "enablePullDownRefresh": false
+            }
+        }
 	],
 	"globalStyle": {
 		"navigationBarTextStyle": "black",

pages/index/index.vue

@@ -14,6 +14,7 @@
 		
 		<button @tap="testStartWifi">初始化wifi模块</button>
 		<button @tap="testGetWifiList">获取当前wifi列表</button>
+		<button @tap="testOffGetWifiList">移除wifi列表监听</button>
 		<button @tap="testGetConnnectWifi">获取当前连接的wifi</button>
 		<button @tap="testConnnectWifi">链接wifi</button>
 		<button @tap="testStopWifi">关闭wifi模块</button>
@@ -39,15 +40,26 @@
 				console.log(res);
 			},
 			testConnnectWifi(){
-
-				uni.connectWifi({
-					maunal:false,
-					SSID:"Xiaomi_20D0",
-					password:"BBBB",
-					complete:(res)=>{
-						console.log(res);
+				
+				uni.startWifi({
+					success:(res)=> {
+						console.log("success: " + JSON.stringify(res));
+						uni.connectWifi({
+							maunal:false,
+							SSID:"Xiaomi_20D0",
+							password:"BBB111",
+							complete:(res)=>{
+								console.log(res);
+							}
+						});
+					},fail:(res)=>{
+						console.log("fail: " + JSON.stringify(res));
+					},complete:(res)=>{
+						console.log("complete: " + JSON.stringify(res));
 					}
-				});
+				})
+
+				
 				
 			},
 			testGetConnnectWifi(){
@@ -96,6 +108,9 @@
 				})
 			},
 			testStopWifi() {
+				uni.offWifiConnected()
+				uni.offWifiConnectedWithPartialInfo()
+				
 				uni.stopWifi({
 					success:(res)=> {
 						console.log("success: " + JSON.stringify(res));
@@ -119,6 +134,13 @@
 				})
 				
 			},
+			
+			testOffGetWifiList(){
+				uni.offGetWifiList()
+			},
+			
+	
+			
 			testonMemoryWarning() {
 				uni.onMemoryWarning(this.onMemoryWarning)
 				uni.showToast({

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

@@ -16,69 +16,37 @@ import WifiConfiguration from 'android.net.wifi.WifiConfiguration';
 import AuthAlgorithm from 'android.net.wifi.WifiConfiguration.AuthAlgorithm';
 import KeyMgmt from 'android.net.wifi.WifiConfiguration.KeyMgmt';
 import TextUtils from 'android.text.TextUtils';
+import Build from 'android.os.Build';
 
-/**
- * Wifi 函数通用入参封装
- */
-type WifiOption = {
-	success?: (res: object) => void;
-	fail?: (res: object) => void;
-	complete?: (res: object) => void;
-};
+import { UniWifiResult, GetConnectedWifiOptions, WifiConnectOption, WifiOption, UniWifiInfo } from "../interface.uts"
 
 
-/**
- * 获取当前链接的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 +55,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?)
@@ -99,78 +67,100 @@ function isHexWepKey(wepKey:string):boolean {
 
 	return isHex(wepKey);
 }
+/**
+ * android 平台特有的Wifi信息对象，主要是加了加密信息这个字段
+ */
+export type AndroidUniWifiInfo = {
+	SSID : string;
+	BSSID ?: string;
+	secure : boolean;
+	signalStrength : number;
+	frequency : number;
+	securityType : string;
+}
 
-
+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
+}
 /**
- * Wifi信息统一数据结构
+ * 从扫描结果中提取统一的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 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;
 		}
+
+		/*扩展字段*/
+		ret.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;
+	return ret
+}
+/**
+ * 从链接信息中提取统一的wifi数据结构
+ */
+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);
 		}
-			
-			this.BSSID = connectInfo.getBSSID();
-			//Android返回的值是-100~0，而微信API规范是0~100，值越大信号越好，需要+100拉齐
-			this.signalStrength = connectInfo.getRssi() + 100; 
-			this.frequency = connectInfo.getFrequency();
-		
+		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时使用，根据用户输入内容包装为系统需要的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 +169,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 +190,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 +202,55 @@ 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 +258,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 +289,7 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 					}
 					// 封装仅SSID 数据对象
 					var connectedWithPartialInfo = {
-						SSID:uniWifiInfo.SSID
+						SSID: uniWifiInfo.SSID
 					}
 					for (let perCallback in Global.onWifiConnectWithPartialInfoCallbackList) {
 						perCallback(connectedWithPartialInfo);
@@ -301,6 +302,7 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 
 
 		if (intent.action == WifiManager.SCAN_RESULTS_AVAILABLE_ACTION) {
+			startWifiScaning = false;
 			// wifi 扫描结果回调
 			let results = this.mWifiManager!.scanResults;
 
@@ -310,7 +312,7 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 					if (scanResult.SSID == null) {
 						continue;
 					}
-					Global.scanList.push(new UniWifiInfo(scanResult));
+					Global.scanList.push(wrapUniWifiInfoFromScan(scanResult));
 				}
 
 				// 挨个通知，所有的监听器
@@ -332,20 +334,24 @@ class CustomBroadcastReceiver extends BroadcastReceiver {
 
 
 /************************* 下面是对外提供的函数 *************************/
+/**
+ * start wifi是否正在扫描
+ */
+var startWifiScaning = false
 
 /**
  * 开启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) {
@@ -357,16 +363,16 @@ export function startWifi(option: WifiOption) {
 
 		return;
 	}
-
+	
 	// 具备了权限，继续前进
-	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 +388,65 @@ 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 = []
 		}
-		
+
 	});
+	startWifiScaning = true
 	// 开始扫描
 	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,14 +457,14 @@ 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)
 }
 
@@ -464,94 +472,91 @@ export function onWifiConnectedWithPartialInfo(callback: UTSCallback) {
 /**
  * wifi 链接成功的回调取消注册
  */
-export function offWifiConnected(callback: UTSCallback) {
+export function offWifiConnected(callback? : UTSCallback) {
+	
+	if(callback == null){
+		Global.onWifiConnectCallbackList = []
+		return
+	}
+	
 	let callbackIndex = Global.onWifiConnectCallbackList.indexOf(callback)
-	if (callbackIndex > 0) {
+	if (callbackIndex >= 0) {
 		Global.onWifiConnectCallbackList.splice(callbackIndex, 1);
 	}
 }
 
-export function offWifiConnectedWithPartialInfo(callback: UTSCallback) {
+/**
+ * 不具备详细信息的wifi 反注册
+ */
+export function offWifiConnectedWithPartialInfo(callback? : UTSCallback) {
+	
+	if(callback == null){
+		Global.onWifiConnectWithPartialInfoCallbackList = []
+		return
+	}
+	
 	let callbackIndex = Global.onWifiConnectWithPartialInfoCallbackList.indexOf(callback)
-	if (callbackIndex > 0) {
+	if (callbackIndex >= 0) {
 		Global.onWifiConnectWithPartialInfoCallbackList.splice(callbackIndex, 1);
 	}
 }
 
 /**
- * 注册Wifi列表的监听事件
- */
-export function onGetWifiList(callback: UTSCallback) {
+	* 注册Wifi列表的监听事件
+	*/
+export function onGetWifiList(callback : UTSCallback) {
 	Global.getWifiListCallbackList.push(callback)
 }
+
 /**
  * 取消注册Wifi列表的监听事件
  */
-export function offGetWifiList(callback: UTSCallback) {
+export function offGetWifiList(callback? : UTSCallback) {
+	if(callback == null){
+		Global.getWifiListCallbackList = []
+		return
+	}
 	let callbackIndex = Global.getWifiListCallbackList.indexOf(callback)
-	if (callbackIndex > 0) {
+	if (callbackIndex >= 0) {
 		Global.getWifiListCallbackList.splice(callbackIndex, 1);
 	}
 }
 
 
 /**
- * 链接指定wifi
+ * 真正执行wifi链接逻辑
  */
-@Suppress("UNUSED_PARAMETER","DEPRECATION")
-export function connectWifi(option: WifiConnectOption) {
-	
-
-	var result = {
-		errCode: 12000,
-		errMsg: "connectWifi:fail:not invoke startWifi",
-		errSubject:"uni-connectWifi",
-	}
+function realWifiConnect(option : WifiConnectOption,result : UniWifiResult){
 	
 	if (Global.mReceiver == null || Global.scanList.length < 1) {
-		// 还没调用startWifi 提示报错
 		option.fail?.(result)
 		option.complete?.(result)
-	
-		return
-	}
-	
-	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,83 +565,91 @@ 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){
-			// 移除之前的配置失败了，返回错误，需要用户手动取消保存一下
-			result.errCode = 12013
-			result.errMsg = "connectWifi:wifi config may be expired"
+		if (!removeRet) {
+			
+			// add since 2023-03-28，如果当前系统大于等于android10， 则明确当前系统不支持
+			if(Build.VERSION.SDK_INT > 28){
+				// 系统大于android 9
+				result.errCode = 12001
+				result.errMsg = "connectWifi:system not support"
+			}else{
+				// 移除之前的配置失败了，返回错误，需要用户手动取消保存一下
+				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)
@@ -645,19 +658,71 @@ export function connectWifi(option: WifiConnectOption) {
 	
 	option.success?.(result)
 	option.complete?.(result)
+}
+
+/**
+ * 链接指定wifi
+ */
+@Suppress("UNUSED_PARAMETER", "DEPRECATION")
+export function connectWifi(option : WifiConnectOption) {
+
+
+	var result : UniWifiResult = {
+		errCode: 12000,
+		errMsg: "connectWifi:fail:not invoke startWifi",
+		errSubject: "uni-connectWifi",
+	}
+
+	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
+	}
+
+	
+	
+	// add since 2022-03-28 ，增加逻辑，如果正在扫描中，则可以等待5s
+	if(startWifiScaning){
+		let taskCount = 0
+		let taskId:number  = 0
+		taskId = setInterval(function(){
+		
+			taskCount += 1;
+			if(taskCount >= 5 || startWifiScaning == false){
+				// 超过10s了。或者扫描过程结束了
+				clearInterval(taskId)
+				realWifiConnect(option,result)
+			}
+		},2000)
+		
+		UTSAndroid.onAppActivityDestroy(function () {
+			clearInterval(taskId)
+		});
+	}else{
+		realWifiConnect(option,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 +730,20 @@ 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,
+	Global.getWifiListCallbackList = []
+	Global.onWifiConnectWithPartialInfoCallbackList = []
+	Global.onWifiConnectCallbackList = []
+
+	let result : UniWifiResult = {
 		errCode: 0,
+		errSubject: "uni-stopWifi",
 		errMsg: "stopWifi:ok"
 	}
 	option.success?.(result)
@@ -686,36 +755,37 @@ export function stopWifi(option: WifiOption) {
  * 获取当前连接中的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
 	}
-	
+
+	// 需要先校验权限，没有位置权限无法获取wifi
 	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;
 	}
 
-	// TODO 应该try catch一下，把系统的错误码给返回来，然后和微信的错误码拉齐
-	// 需要先校验权限，没有位置权限无法获取wifi
 	const context = UTSAndroid.getAppContext();
 	if (context != null) {
 		const wm = context.getSystemService(
@@ -724,31 +794,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!= null) {
+			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/app-ios/index.uts

@@ -3,60 +3,7 @@ import { CaptiveNetwork, kCNNetworkInfoKeySSID, kCNNetworkInfoKeyBSSID } from 'S
 import { NSArray, NSDictionary } from 'Foundation';
 import { CFString } from 'CoreFoundation';
 import { UIDevice } from 'UIKit';
-
-/**
- * Wifi 函数通用入参封装
- */
-type WifiOption = {
-	success?: (res: UniWifiResult) => void;
-	fail?: (res: UniWifiResult) => void;
-	complete?: (res: UniWifiResult) => void;
-};
-
-/**
- * Wifi 链接参数封装 
- */
-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信息
- */
-type GetConnectedWifiOptions = {
-	partialInfo?: boolean
-	success?: (res: UniWifiResult) => void
-	fail?: (res: UniWifiResult) => void
-	complete?: (res: UniWifiResult) => void
-}
-
-/* 
- * 对外暴露的wifi信息
- */
-type UniWifiInfo = {
-	SSID: string;
-	BSSID: string;
-	secure: boolean;
-	signalStrength: number;
-	frequency: number;
-}
-
-type UniWifiResult = {
-	errCode : number,
-	errSubject : string,
-	errMsg : string,
-	wifi: UniWifiInfo | null
-}
-
-type UniWifiCallback = () => void
-
+import { WifiOption, WifiConnectOption, GetConnectedWifiOptions, UniWifiInfo, UniWifiResult, UniWifiCallback, StartWifi, StopWifi, GetWifiList, OnGetWifiList, OffGetWifiList, GetConnectedWifi, ConnectWifi, OnWifiConnected, OnWifiConnectedWithPartialInfo, OffWifiConnected, OnOffWifiConnectedWithPartialInfo, SetWifiList } from "../interface.uts"
 
 /* 
  * 系统定位权限获取类
@@ -135,7 +82,7 @@ function fetchConnectedWifiWithLocationPromise(option: GetConnectedWifiOptions)
 		let list = arr! as NSArray
 		let index = 0
 		while (index < list.count) { 
-			let item = list[index]
+			let item = list[index] 
 			let interfaceName = item as string
 			let dic = CNCopyCurrentNetworkInfo(interfaceName as CFString)
 			if (dic != null) {
@@ -157,7 +104,7 @@ function fetchConnectedWifiWithLocationPromise(option: GetConnectedWifiOptions)
 			index++
 		}
 		
-		if (wifiInfo.BSSID.length > 0 && wifiInfo.SSID.length > 0) {
+		if (wifiInfo.BSSID!.length > 0 && wifiInfo.SSID.length > 0) {
 			let res: UniWifiResult = {
 				errSubject: "uni-getConnectedWifi",
 				errCode: 0,
@@ -204,7 +151,7 @@ class UniWiFiModuleGloabInfo {
 /* 
  * 初始化wifi模块 
  */
-export function startWifi(option: WifiOption) {
+export const startWifi: StartWifi = function (option: WifiOption) {
 	UniWiFiModuleGloabInfo.alreadyStartWifi = true
 	let res: UniWifiResult = {
 		errSubject: "uni-startWifi",
@@ -219,7 +166,7 @@ export function startWifi(option: WifiOption) {
 /* 
  * 停止wifi模块 
  */
-export function stopWifi(option: WifiOption) {
+export const stopWifi: StopWifi = function (option: WifiOption) {
 	UniWiFiModuleGloabInfo.alreadyStartWifi = false
 	LocationPromiseService.promiseCompletionHandler = []	
 	let res: UniWifiResult = {
@@ -235,7 +182,7 @@ export function stopWifi(option: WifiOption) {
 /* 
  * 获取wifi列表, 在调用之前需要引导用户跳转到系统设置-WIFI设置页面，系统搜索周边wifi后app才能接收到回调
  */
-export function getWifiList(option: WifiOption) {
+export const getWifiList: GetWifiList = function (option: WifiOption) {
 	let res: UniWifiResult = {
 		errSubject: "uni-getWifiList",
 		errCode: 12001, 
@@ -249,14 +196,14 @@ export function getWifiList(option: WifiOption) {
 /* 获取wifi列表的回调
  * note: 请在getWifiList方法的回调里调用该方法
  */
-export function onGetWifiList(callback: UniWifiCallback) {
+export const onGetWifiList: OnGetWifiList = function (callback: UniWifiCallback) {
 	
 }
 
 /* 
  *	注销获取wifi列表的回调
  */
-export function offGetWifiList(callback: UniWifiCallback) {
+export const offGetWifiList: OffGetWifiList = function (callback: UniWifiCallback) {
 
 }
 
@@ -264,7 +211,7 @@ export function offGetWifiList(callback: UniWifiCallback) {
 /* 
  * 获取当前连接的wifi信息
  */
-export function getConnectedWifi(option: GetConnectedWifiOptions) {
+export const getConnectedWifi: GetConnectedWifi = function (option: GetConnectedWifiOptions) {
 	if (UniWiFiModuleGloabInfo.alreadyStartWifi == false) {
 		let res: UniWifiResult = {
 			errSubject: "uni-getConnectedWifi",
@@ -299,7 +246,7 @@ export function getConnectedWifi(option: GetConnectedWifiOptions) {
 /* 
  * 连接wifi
  */
-export function connectWifi(option: WifiConnectOption) {
+export const connectWifi: ConnectWifi = function (option: WifiConnectOption) {
 	let res: UniWifiResult = {
 		errSubject: "uni-connectWifi",
 		errCode: 12001, 
@@ -314,35 +261,35 @@ export function connectWifi(option: WifiConnectOption) {
 /* 
  * 连上wifi事件的监听函数
  */
-export function onWifiConnected(callback: UniWifiCallback) {
+export const onWifiConnected: OnWifiConnected = function (callback: UniWifiCallback) {
 	
 }
 
 /* 
  * 连上wifi事件的监听函数， wifiInfo仅包含ssid
  */
-export function onWifiConnectedWithPartialInfo(callback: UniWifiCallback) {
+export const onWifiConnectedWithPartialInfo: OnWifiConnectedWithPartialInfo = function (callback: UniWifiCallback) {
 	
 }
 
 /* 
  *	移除连接上wifi的事件的监听函数，不传此参数则移除所有监听函数。
  */
-export function offWifiConnected(callback: UniWifiCallback | null) {
+export const offWifiConnected: OffWifiConnected = function (callback: UniWifiCallback | null) {
 
 }
 
 /* 
  *	移除连接上wifi的事件的监听函数，不传此参数则移除所有监听函数。
  */
-export function onOffWifiConnectedWithPartialInfo(callback: UniWifiCallback | null) {
+export const onOffWifiConnectedWithPartialInfo: OnOffWifiConnectedWithPartialInfo = function (callback: UniWifiCallback | null) {
 
 }
 
 /* 
  * 设置 wifiList 中 AP 的相关信息。在 onGetWifiList 回调后调用，iOS特有接口。
  */
-export function setWifiList(option: WifiOption) {
+export const setWifiList: SetWifiList = function (option: WifiOption) {
 	let res: UniWifiResult = {
 		errSubject: "uni-setWifiList",
 		errCode: 12001, 

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,
+	/**
+	 * @autotest {
+		generated: false,
+		pollution: false,
+		cases:[
+			{
+				before: 'startWifi',
+				after: 'stopWifi',
+				input: [{
+					maunal:false,
+					SSID:"Xiaomi_20D0",
+					password:"streamApp!2016",
+				}],
+				output:{
+				    	callbackType: 'success',
+				        value: { errCode: 12013 ,errMsg: "connectWifi:wifi config may be expired",errSubject: "uni-connectWifi"}
+				    }
+			}
+		]
+	}
+	*/
+	connectWifi: ConnectWifi,
+	/**
+	 * @autotest {
+		generated: false,
+		cases:[
+			{
+				before: 'startWifi',
+				after: 'stopWifi'
+			}
+		]
+	}
+	*/
+	getWifiList : GetWifiList,
+	onGetWifiList : OnGetWifiList,
+	offGetWifiList : OffGetWifiList,
+	getConnectedWifi : GetConnectedWifi,
+	onWifiConnected : OnWifiConnected,
+	onWifiConnectedWithPartialInfo : OnWifiConnectedWithPartialInfo,
+	offWifiConnected : OffWifiConnected,
+	onOffWifiConnectedWithPartialInfo : OnOffWifiConnectedWithPartialInfo,
+	setWifiList : SetWifiList,
+}

uni_modules/uni-wifi/utssdk/uni.autotest.js

+function startWifi() {
+	return new Promise((resolve, reject) => {
+		uni.startWifi({
+			success: () => {
+				console.log('startWifi success');
+				resolve()
+			},
+			fail: () => {
+				console.log('startWifi fail');
+				reject()
+			}
+		})
+	})
+}
+
+function stopWifi() {
+	return new Promise((resolve, reject) => {
+		uni.stopWifi({
+			success: () => {
+				console.log('stopWifi success');
+				resolve()
+			},
+			fail: () => {
+				console.log('stopWifi success');
+				fail()
+			}
+		})
+	})
+}
+
+
+module.exports = {
+	startWifi,
+	stopWifi
+}