Merge branch 'dev'

.gitignore

 /unpackage
+/.hbuilderx
+/.vite
+.DS_Store
\ No newline at end of file

.hbuilderx/launcher/hx_iOS_resign.json

+{"index":1}
\ No newline at end of file

manifest.json

@@ -68,5 +68,5 @@
     "uniStatistics" : {
         "enable" : false
     },
-    "vueVersion" : "3"
+    "vueVersion" : "2"
 }

pages/index/index.vue

@@ -5,27 +5,130 @@
 			<text class="title">{{title}}</text>
 		</view>
 		<button @tap="testScreenShotListen">开启截屏监听</button>
-		<button  @tap="testScreenShotOff">关闭截屏监听</button>
-		<button  @tap="testGetBatteryInfo">获取电池电量</button>
-
+		<button @tap="testScreenShotOff">关闭截屏监听</button>
+		<button @tap="testGetBatteryInfo">获取电池电量</button>
+		<button @tap="testonMemoryWarning">开启内存不足告警监听</button>
+		<button @tap="testoffMemoryWarning">关闭内存不足告警监听</button>
+		
+		<button @tap="testStartWifi">初始化wifi模块</button>
+		<button @tap="testGetWifiList">获取当前wifi列表</button>
+		<button @tap="testGetConnnectWifi">获取当前连接的wifi</button>
+		<button @tap="testConnnectWifi">链接wifi</button>
+		<button @tap="testStopWifi">关闭wifi模块</button>
 	</view>
 </template>
 
 <script>
 
-	import getBatteryInfo from "@/uni_modules/uni-getbatteryinfo";
-	
 	export default {
 		data() {
 			return {
-				title: 'Hello'
+				title: 'Hello',
+				memListener:null,
 			}
 		},
 		onLoad() {
 
 		},
 		methods: {
-			
+			onMemoryWarning:function(res){
+				console.log(res);
+			},
+			testConnnectWifi(){
+
+				uni.connectWifi({
+					maunal:false,
+					SSID:"Xiaomi_20D0",
+					password:"BBBB",
+					complete:(res)=>{
+						console.log(res);
+					}
+				});
+				
+			},
+			testGetConnnectWifi(){
+				uni.getConnectedWifi({
+					partialInfo:false,
+					complete:(res)=>{
+						console.log(res);
+						if (res.errCode == 0) {
+							uni.showToast({
+								icon:'none',
+								title:res.wifi.SSID
+							})
+						} else{
+							uni.showToast({
+								icon:'none',
+								title:res.errMsg
+							})
+						}
+						
+					}
+				});
+			},
+			testStartWifi(){
+				uni.startWifi({
+					success:(res)=> {
+						console.log("success: " + JSON.stringify(res));
+						// wifi 开启成功后，注册wifi链接状态监听和wifi列表获取监听
+						uni.onGetWifiList(function(res){
+							console.log("onGetWifiList");
+							console.log(res);
+						});
+						uni.onWifiConnected(function(res){
+							console.log("onWifiConnected");
+							console.log(res);
+						});
+						uni.onWifiConnectedWithPartialInfo(function(res){
+							console.log("onWifiConnectedWithPartialInfo");
+							console.log(res);
+						});
+						
+					},fail:(res)=>{
+						console.log("fail: " + JSON.stringify(res));
+					},complete:(res)=>{
+						console.log("complete: " + JSON.stringify(res));
+					}
+				})
+			},
+			testStopWifi() {
+				uni.stopWifi({
+					success:(res)=> {
+						console.log("success: " + JSON.stringify(res));
+					},fail:(res)=>{
+						console.log("fail: " + JSON.stringify(res));
+					},complete:(res)=>{
+						console.log("complete: " + JSON.stringify(res));
+					}
+				})
+				
+			},
+			testGetWifiList() {
+				uni.getWifiList({
+					success:(res)=> {
+						console.log("success: " + JSON.stringify(res));
+					},fail:(res)=>{
+						console.log("fail: " + JSON.stringify(res));
+					},complete:(res)=>{
+						console.log("complete: " + JSON.stringify(res));
+					}
+				})
+				
+			},
+			testonMemoryWarning() {
+				uni.onMemoryWarning(this.onMemoryWarning)
+				uni.showToast({
+					icon:'none',
+					title:'已监听，注意控制台输出'
+				})
+			},
+			testoffMemoryWarning(){
+				uni.offMemoryWarning(this.onMemoryWarning)
+				uni.showToast({
+					icon:'none',
+					title:'监听已移除'
+				})
+			},
 			testScreenShotListen() {
 				var that = this;
 				uni.onUserCaptureScreen(function(res) {
@@ -67,7 +170,6 @@
 					}
 			},
 			testScreenShotOff() {
-				var that = this;
 				uni.offUserCaptureScreen(function(res) {
 						console.log(res);
 				});
@@ -78,9 +180,9 @@
 				})
 			},
 			testGetBatteryInfo() {
-				var that = this;
 				uni.getBatteryInfo({
 					success(res) {
+						console.log(res);
 						uni.showToast({
 							title: "当前电量：" + res.level + '%',
 							icon: 'none'

uni_modules/uni-getbatteryinfo/index.d.ts

@@ -25,7 +25,7 @@ interface GetBatteryInfoOption {
   success?: (result: GetBatteryInfoSuccessCallbackResult) => void
 }
 
-declare class Uni {
+declare interface Uni {
   /**
    * 获取设备电量
    *

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

 import Context from "android.content.Context";
 import BatteryManager from "android.os.BatteryManager";
-import { getAppContext } from "io.dcloud.uts.android";
+import { UTSAndroid } from "io.dcloud.uts";
 
 
 type GetBatteryInfoOptions = {
@@ -10,7 +10,7 @@ type GetBatteryInfoOptions = {
 }
 
 export default function getBatteryInfo(options: GetBatteryInfoOptions) {
-    const context = getAppContext();
+    const context = UTSAndroid.getAppContext();
     if (context != null) {
         const manager = context.getSystemService(
             Context.BATTERY_SERVICE
@@ -19,6 +19,8 @@ export default function getBatteryInfo(options: GetBatteryInfoOptions) {
             BatteryManager.BATTERY_PROPERTY_CAPACITY
         );
         const res = {
+			errSubject: "uni-getBatteryInfo",
+			errCode: 0, 
             errMsg: 'getBatteryInfo:ok',
             level,
             isCharging: manager.isCharging()
@@ -27,6 +29,8 @@ export default function getBatteryInfo(options: GetBatteryInfoOptions) {
         options.complete?.(res)
     } else {
         const res = {
+			errSubject: "uni-getBatteryInfo",
+			errCode: 1001, 
             errMsg: 'getBatteryInfo:fail getAppContext is null'
         }
         options.fail?.(res)

uni_modules/uni-getbatteryinfo/utssdk/app-ios/config.json

-{
-  "deploymentTarget": "9"
-}
\ No newline at end of file

uni_modules/uni-getbatteryinfo/utssdk/app-ios/index.uts

+// 引用 iOS 原生平台 api
 import { UIDevice } from "UIKit";
+import { Int } from 'Swift';
 
+/**
+ * 定义 接口参数
+ */
 type GetBatteryInfoOptions = {
-    success?: (res: UTSJSONObject) => void;
-    fail?: (res: UTSJSONObject) => void;
-    complete?: (res: UTSJSONObject) => void;
+    success?: (res: object) => void;
+    fail?: (res: object) => void;
+    complete?: (res: object) => void;
 };
 
+/**
+ * 导出 获取电量方法 
+ */
 export default function getBatteryInfo(options: GetBatteryInfoOptions) {
 	
+	// 开启电量检测
 	UIDevice.current.isBatteryMonitoringEnabled = true
 	
+	// 返回数据
     const res = {
         errMsg: "getBatteryInfo:ok",
-        level: Number(UIDevice.current.batteryLevel * 100),
+        level: new Int(UIDevice.current.batteryLevel * 100),
         isCharging: UIDevice.current.batteryState == UIDevice.BatteryState.charging,
     };
     options.success?.(res);
     options.complete?.(res);
-}
+}
\ No newline at end of file

uni_modules/uni-memorywarning/changelog.md

+## 1.1.0（2022-12-05）
+实现iOS平台内存警告监听
+## 1.0.0（2022-11-12）  
+实现Android平台内存警告监听功能  

uni_modules/uni-memorywarning/package.json

+{
+  "id": "uni-memorywarning",
+  "displayName": "uni-MemoryWarning",
+  "version": "1.1.0",
+  "description": "UTS 实现内存警告监听",
+  "keywords": [
+    "onMemoryWarning"
+],
+  "repository": "",
+  "engines": {
+    "HBuilderX": "^3.6.11"
+  },
+  "dcloudext": {
+    "type": "uts",
+    "sale": {
+      "regular": {
+        "price": "0.00"
+      },
+      "sourcecode": {
+        "price": "0.00"
+      }
+    },
+    "contact": {
+      "qq": ""
+    },
+    "declaration": {
+      "ads": "无",
+      "data": "无",
+      "permissions": "无"
+    },
+    "npmurl": ""
+  },
+  "uni_modules": {
+	"uni-ext-api":{
+		"uni": {
+			"onMemoryWarning": "onMemoryWarning",
+			"offMemoryWarning":"offMemoryWarning"
+		},
+		"mp-weixin":false,
+		"mp-alipay":false,
+		"mp-baidu":false,
+		"mp-qq":false,
+		"mp-kuaishou":false,
+		"mp-jd":false
+	},
+    "dependencies": [],
+    "encrypt": [],
+    "platforms": {
+      "cloud": {
+        "tcb": "y",
+        "aliyun": "y"
+      },
+      "client": {
+        "Vue": {
+          "vue2": "y",
+          "vue3": "y"
+        },
+        "App": {
+          "app-android": {
+            "minVersion": "19"
+        },
+          "app-ios": {
+            "minVersion": "9"
+        }
+        },
+        "H5-mobile": {
+          "Safari": "n",
+          "Android Browser": "n",
+          "微信浏览器(Android)": "n",
+          "QQ浏览器(Android)": "n"
+        },
+        "H5-pc": {
+          "Chrome": "n",
+          "IE": "n",
+          "Edge": "n",
+          "Firefox": "n",
+          "Safari": "n"
+        },
+        "小程序": {
+          "微信": "n",
+          "阿里": "n",
+          "百度": "n",
+          "字节跳动": "n",
+          "QQ": "n",
+          "钉钉": "n",
+          "快手": "n",
+          "飞书": "n",
+          "京东": "n"
+        },
+        "快应用": {
+          "华为": "n",
+          "联盟": "n"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file

uni_modules/uni-memorywarning/readme.md

+## 使用说明
+
+### uni.onMemoryWarning(CALLBACK)
+
+监听内存不足告警事件，当系统应用进程发出内存警告时，触发该事件。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/memory.html#onmemorywarning](https://uniapp.dcloud.net.cn/api/system/memory.html#onmemorywarning)
+
+**注意平台差异：仅Android平台有返回值，iOS平台无返回值**
+
+
+### uni.offMemoryWarning(CALLBACK)
+
+取消监听内存不足告警事件。
+
+onMemoryWarning 传入的监听函数。不传此参数则移除所有监听函数。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/memory.html#offmemorywarning](https://uniapp.dcloud.net.cn/api/system/memory.html#offmemorywarning)
+

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

+import { UTSAndroid } from "io.dcloud.uts"
+
+let listeners: UTSCallback[] = []
+
+const onAppTrimMemoryListener = (res: number) => {
+    listeners.forEach(listener => {
+        listener(res)
+    })
+}
+
+
+@Suppress("DEPRECATION")
+export function onMemoryWarning(callback: (res: number) => void) {
+    if (listeners.length == 0) {
+		// 仅首次执行底层的实际监听
+        UTSAndroid.onAppTrimMemory(onAppTrimMemoryListener)
+		UTSAndroid.onAppActivityDestroy(()=>{
+			// listeners 默认是静态常量周期，activity 销毁时，需要手动清空
+			listeners = []
+		})
+    }
+    listeners.push(callback)
+}
+
+@Suppress("DEPRECATION")
+export function offMemoryWarning(callback: UTSCallback | null = null) {
+	
+	if(callback == null){
+		// 清除全部回调
+		listeners = []
+		UTSAndroid.offAppTrimMemory(null);
+		return
+	}
+	
+	// 清除指定回调
+    const index = listeners.indexOf(callback)
+    if (index > -1) {
+        listeners.splice(index, 1)
+    }
+    if (listeners.length == 0) {
+        // 当用户不再监听时，移除底层实际监听
+        UTSAndroid.offAppTrimMemory(onAppTrimMemoryListener)
+    }
+}

uni_modules/uni-memorywarning/utssdk/app-ios/index.uts

+import { NotificationCenter } from 'Foundation';
+import { UIApplication } from "UIKit"
+import { Selector } from "ObjectiveC"
+
+class MemoryWarningTool {
+	static listeners: UTSCallback[] = []
+	
+	// 监听内存警告
+	static listenMemoryWarning(callback: UTSCallback) {
+		
+		// 只有首次才需要注册监听事件
+		if (this.listeners.length == 0) {
+			// 注册监听内存警告通知事件及设置回调方法
+			// target-action 回调方法需要通过 Selector("方法名") 构建
+			const method = Selector("receiveMemoryWarning")
+			NotificationCenter.default.addObserver(this, selector = method, name = UIApplication.didReceiveMemoryWarningNotification, object = null)
+		}
+		this.listeners.push(callback)
+	}
+	
+	// 内存警告回调的方法
+	// target-action 的方法前需要添加 @objc 前缀
+	@objc static receiveMemoryWarning() {
+		// 触发回调
+		this.listeners.forEach(listener => {
+			listener({})
+		})
+	}
+	
+	// 移除监听事件
+	static removeListen(callback: UTSCallback | null) {
+		// 移除所有监听
+		if (callback == null) {
+			this.listeners = []
+			// 移除监听事件
+			NotificationCenter.default.removeObserver(this)
+			return
+		}
+		
+		// 清除指定回调
+		const index = this.listeners.indexOf(callback!)
+		if (index > -1) {
+		    this.listeners.splice(index, 1)
+		}
+	}
+}
+
+// 开启监听内存警告
+export function onMemoryWarning(callback: UTSCallback) {
+	MemoryWarningTool.listenMemoryWarning(callback)
+}
+
+// 关闭监听内存警告
+export function offMemoryWarning(callback: UTSCallback | null) {
+	MemoryWarningTool.removeListen(callback)
+}
\ No newline at end of file

uni_modules/uni-usercapturescreen/index.d.ts

 type OnUserCaptureScreenCallback = (res?: { errMsg: string }) => void
 
-declare class Uni {
+declare interface Uni {
   /**
    * 监听用户主动截屏事件，用户使用系统截屏按键截屏时触发此事件。
    *

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

 
 
 import {
-	getUniActivity
-} from "io.dcloud.uts.android";
+	UTSAndroid
+} from "io.dcloud.uts";
 
 
 import ActivityCompat from "androidx.core.app.ActivityCompat";
@@ -35,7 +35,7 @@ let imageChange: UTSCallback | null = null;
 /**
  * android 文件监听实现
  */
-
+@Suppress("DEPRECATION")
 class ScreenFileObserver extends FileObserver {
 
 	/**
@@ -45,8 +45,9 @@ class ScreenFileObserver extends FileObserver {
 
 	
 	constructor(screenFile: string) {
-		super(screenFile)
+		super(new File(screenFile))
 		this.allScreen = new File(screenFile);
+		
 	}
 
 
@@ -84,12 +85,13 @@ class ScreenFileObserver extends FileObserver {
 /**
  * 开启截图监听
  */
+@Suppress("DEPRECATION")
 export function onUserCaptureScreen(callback: (res:UTSJSONObject) => void) {
 	
 	// 检查相关权限是否已经具备
-	if (ActivityCompat.checkSelfPermission(getUniActivity()!, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+	if (ActivityCompat.checkSelfPermission(UTSAndroid.getUniActivity()!, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
 		// 不具备权限，申请权限，并且告知用户监听失败
-		ActivityCompat.requestPermissions(getUniActivity()!, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), 1001)
+		ActivityCompat.requestPermissions(UTSAndroid.getUniActivity()!, arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), 1001)
 		
 		// 因权限缺失导致监听失败
 		let ret = {
@@ -106,7 +108,7 @@ export function onUserCaptureScreen(callback: (res:UTSJSONObject) => void) {
 	let directory_pictures = new File(Environment.getExternalStorageDirectory(), Environment.DIRECTORY_PICTURES);
 	let directory_dcim = new File(Environment.getExternalStorageDirectory(), Environment.DIRECTORY_DCIM);
 	
-	if (Build.MANUFACTURER.lowercase() === "xiaomi") {
+	if (Build.MANUFACTURER.toLowerCase() === "xiaomi") {
 		directory_screenshot = new File(directory_dcim, "Screenshots");
 	} else {
 		directory_screenshot = new File(directory_pictures, "Screenshots");

uni_modules/uni-usercapturescreen/utssdk/app-ios/index.uts

-import { NotificationCenter} from 'Foundation';
+import { NotificationCenter } from 'Foundation';
 import { UIApplication } from "UIKit"
+import { Selector } from "ObjectiveC"
 
 /**
  * 定义监听截屏事件工具类
  */
 class CaptureScreenTool {
-	static listener?: UTSCallback;
+	static listener: UTSCallback | null;
 	
 	// 监听截屏
-	static listenCaptureScreen(callback?: UTSCallback) {
+	static listenCaptureScreen(callback: UTSCallback | null) {
 		this.listener = callback
 		
-		// 注册监听截屏事件及回调方法
+		// 注册监听截屏通知事件及设置回调方法
 		// target-action 回调方法需要通过 Selector("方法名") 构建
 		const method = Selector("userDidTakeScreenshot")
 		NotificationCenter.default.addObserver(this, selector = method, name = UIApplication.userDidTakeScreenshotNotification, object = null)
@@ -20,30 +21,28 @@ class CaptureScreenTool {
 	// 捕获截屏回调的方法
 	// target-action 的方法前需要添加 @objc 前缀
 	@objc static userDidTakeScreenshot() {
-		const obj = new UTSJSONObject()
-		// 回调
-		this.listener?.(obj)
+		// 触发回调
+		this.listener?.({})
 	}
 	
 	// 移除监听事件
-	static removeListen(callback?: UTSCallback) {
+	static removeListen(callback: UTSCallback | null) {
 		this.listener = null
 		NotificationCenter.default.removeObserver(this)
-		const obj = new UTSJSONObject()
-		callback?.(obj)
+		callback?.({})
 	}
 }
 
 /**
  * 开启截图监听
  */
-export function onUserCaptureScreen(callback?: UTSCallback) {
+export function onUserCaptureScreen(callback: UTSCallback | null) {
 	CaptureScreenTool.listenCaptureScreen(callback)
 }
 
 /**
  * 关闭截屏监听
  */
-export function offUserCaptureScreen(callback?: UTSCallback) {
+export function offUserCaptureScreen(callback: UTSCallback | null) {
 	CaptureScreenTool.removeListen(callback)
-}
+}
\ No newline at end of file

uni_modules/uni-wifi/changelog.md

+## 1.0.0（2022-12-05）
+实现Android/iOS平台Wi-Fi功能模块  
+注：iOS平台仅支持获取已连接的 Wi-Fi 信息

uni_modules/uni-wifi/package.json

+{
+  "id": "uni-wifi",
+  "displayName": "uni-wifi",
+  "version": "1.0.0",
+  "description": "wifi管理",
+  "keywords": [
+    "wifi"
+],
+  "repository": "",
+  "engines": {
+    "HBuilderX": "^3.6.11"
+  },
+  "dcloudext": {
+    "type": "uts",
+    "sale": {
+      "regular": {
+        "price": "0.00"
+      },
+      "sourcecode": {
+        "price": "0.00"
+      }
+    },
+    "contact": {
+      "qq": ""
+    },
+    "declaration": {
+      "ads": "无",
+      "data": "插件不采集任何数据",
+      "permissions": "Android平台：\n<uses-permission android:name=\"android.permission.ACCESS_WIFI_STATE\"/>\n<uses-permission android:name=\"android.permission.CHANGE_WIFI_STATE\"/>\n<uses-permission android:name=\"android.permission.ACCESS_FINE_LOCATION\"/>\n<uses-permission android:name=\"android.permission.ACCESS_COARSE_LOCATION\"/>\niOS平台：\niOS13及以上平台获取Wifi信息需要定位权限"
+    },
+    "npmurl": ""
+  },
+  "uni_modules": {
+	"uni-ext-api":{
+		"uni": {
+			"startWifi": "startWifi",
+			"stopWifi": "stopWifi",
+			"connectWifi":"connectWifi",
+			"getConnectedWifi": "getConnectedWifi",
+			"getWifiList":"getWifiList",
+			"onGetWifiList":"onGetWifiList",
+			"offGetWifiList":"offGetWifiList",
+			"onWifiConnected":"onWifiConnected",
+			"offWifiConnected":"offWifiConnected",
+			"onWifiConnectedWithPartialInfo":"onWifiConnectedWithPartialInfo",
+			"offWifiConnectedWithPartialInfo":"offWifiConnectedWithPartialInfo"
+		}
+	},
+    "dependencies": [],
+    "encrypt": [],
+    "platforms": {
+      "cloud": {
+        "tcb": "y",
+        "aliyun": "y"
+      },
+      "client": {
+        "Vue": {
+          "vue2": "y",
+          "vue3": "y"
+        },
+        "App": {
+          "app-android": {
+            "minVersion": "19"
+        },
+          "app-ios": {
+            "minVersion": "9"
+        }
+        },
+        "H5-mobile": {
+          "Safari": "n",
+          "Android Browser": "n",
+          "微信浏览器(Android)": "n",
+          "QQ浏览器(Android)": "n"
+        },
+        "H5-pc": {
+          "Chrome": "n",
+          "IE": "n",
+          "Edge": "n",
+          "Firefox": "n",
+          "Safari": "n"
+        },
+        "小程序": {
+          "微信": "n",
+          "阿里": "n",
+          "百度": "n",
+          "字节跳动": "n",
+          "QQ": "n",
+          "钉钉": "n",
+          "快手": "n",
+          "飞书": "n",
+          "京东": "n"
+        },
+        "快应用": {
+          "华为": "n",
+          "联盟": "n"
+        }
+      }
+    }
+  }
+}
\ No newline at end of file

uni_modules/uni-wifi/readme.md

+## 使用说明  
+
+Wi-Fi功能模块
+
+
+### App-iOS平台注意事项  
+- iOS平台App获取Wi-Fi信息需要开启“Access WiFi information”能力  
+  登录苹果开发者网站，在“Certificates, Identifiers & Profiles”页面选择“Identifiers”中选择对应的App ID，确保开启“Access WiFi information”，保存后重新生成profile文件  
+- iOS13及以上系统，获取当前连接的Wi-Fi信息需要先获取系统定位权限，因此在iOS13及以上系统使用此接口时，会触发定位权限申请的弹窗  
+
+### App-Android平台注意事项  
+- 如果是自定义基座，需要具备下面的权限
+
+```
+<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
+<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
+<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+```
+
+
+###uni.startWifi(OBJECT)
+
+初始化Wi-Fi模块。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#startwifi](https://uniapp.dcloud.net.cn/api/system/wifi.html#startwifi)
+
+
+### uni.stopWifi(OBJECT)
+
+关闭 Wi-Fi 模块。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#stopwifi](https://uniapp.dcloud.net.cn/api/system/wifi.html#stopwifi)
+
+
+### uni.getConnectedWifi(OBJECT)
+
+获取已连接的 Wi-Fi 信息
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#getconnectedwifi](https://uniapp.dcloud.net.cn/api/system/wifi.html#getconnectedwifi)
+
+
+### uni.getWifiList(OBJECT)
+
+请求获取 Wi-Fi 列表。wifiList 数据会在 onGetWifiList 注册的回调中返回。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#getWifiList](https://uniapp.dcloud.net.cn/api/system/wifi.html#getWifiList)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.onGetWifiList(CALLBACK)
+
+监听获取到 Wi-Fi 列表数据事件。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#onGetWifiList](https://uniapp.dcloud.net.cn/api/system/wifi.html#onGetWifiList)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.offGetWifiList(CALLBACK)
+
+移除获取到 Wi-Fi 列表数据事件的监听函数。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#offGetWifiList](https://uniapp.dcloud.net.cn/api/system/wifi.html#offGetWifiList)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.connectWifi(OBJECT)
+
+连接 Wi-Fi。若已知 Wi-Fi 信息，可以直接利用该接口连接。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#connectWifi](https://uniapp.dcloud.net.cn/api/system/wifi.html#connectWifi)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.onWifiConnected(CALLBACK)
+
+监听连接上 Wi-Fi 的事件。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#onWifiConnected](https://uniapp.dcloud.net.cn/api/system/wifi.html#onWifiConnected)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.offWifiConnected(CALLBACK)
+
+移除连接上 Wi-Fi 的事件的监听函数。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#offWifiConnected](https://uniapp.dcloud.net.cn/api/system/wifi.html#offWifiConnected)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.onWifiConnectedWithPartialInfo(CALLBACK)
+
+监听连接上 Wi-Fi 的事件。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#onWifiConnectedWithPartialInfo](https://uniapp.dcloud.net.cn/api/system/wifi.html#onWifiConnectedWithPartialInfo)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+
+
+### uni.offWifiConnectedWithPartialInfo(CALLBACK)
+
+移除连接上 Wi-Fi 的事件的监听函数。
+
+> 使用文档：[https://uniapp.dcloud.net.cn/api/system/wifi.html#offWifiConnectedWithPartialInfo](https://uniapp.dcloud.net.cn/api/system/wifi.html#offWifiConnectedWithPartialInfo)
+
+**平台差异说明**
+
+|App-Android|App-iOS|
+|:-:|:-:|
+|√|x|
+

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

+import Context from "android.content.Context";
+import { UTSAndroid } from "io.dcloud.uts";
+import WifiManager from "android.net.wifi.WifiManager";
+import WifiInfo from "android.net.wifi.WifiInfo";
+import Manifest from "android.Manifest";
+import PackageManager from "android.content.pm.PackageManager";
+import ScanResult from "android.net.wifi.ScanResult";
+import BroadcastReceiver from "android.content.BroadcastReceiver";
+import ActivityCompat from "androidx.core.app.ActivityCompat";
+import IntentFilter from "android.content.IntentFilter";
+import JSONObject from "com.alibaba.fastjson.JSONObject";
+import Intent from "android.content.Intent";
+import Thread from "java.lang.Thread";
+
+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';
+
+/**
+ * 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]";
+	// 扫描wifi结果
+	static scanList: UniWifiInfo[] = []
+	// 获取wifi列表监听
+	static getWifiListCallbackList: UTSCallback[] = []
+	// wifi链接监听
+	static onWifiConnectCallbackList: UTSCallback[] = []
+	static onWifiConnectWithPartialInfoCallbackList: UTSCallback[] = []
+}
+
+
+/**
+ * 是否是标准的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')) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * 判断是否是wep格式的key
+ */
+function isHexWepKey(wepKey:string):boolean {
+	let len = wepKey.length;
+
+	// WEP-40, WEP-104, and some vendors using 256-bit WEP (WEP-232?)
+	if (len != 10 && len != 26 && len != 58) {
+		return false;
+	}
+
+	return isHex(wepKey);
+}
+
+
+/**
+ * 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配置对象
+ */
+@Suppress("DEPRECATION")
+function wrapWifiConfiguration(SSID:string ,password:string,passwordType:string):WifiConfiguration {
+		
+	let config = new WifiConfiguration();
+	config.status = WifiConfiguration.Status.ENABLED;
+	config.allowedAuthAlgorithms.clear();
+	config.allowedGroupCiphers.clear();
+	config.allowedKeyManagement.clear();
+	config.allowedPairwiseCiphers.clear();
+	config.allowedProtocols.clear();
+	config.SSID = "\"".concat(SSID).concat("\"");
+	
+	
+	// nopass
+	if ("NONE".equals(passwordType)) {
+		config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
+	}
+	// wep
+	if ("WEP".equals(passwordType)) {
+		if (!TextUtils.isEmpty(password)) {
+			if (isHexWepKey(password)) {
+				config.wepKeys[0] = password;
+			} else {
+				config.wepKeys[0] = "\"".concat(password).concat("\"");
+			}
+		}
+		config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);
+		config.allowedAuthAlgorithms.set(AuthAlgorithm.SHARED);
+		config.allowedKeyManagement.set(KeyMgmt.NONE);
+		config.wepTxKeyIndex = 0;
+	}
+	// wpa
+	if ("WPA".equals(passwordType)) {
+		config.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
+		config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
+		config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
+		config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
+		config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
+		config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
+		config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
+		config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
+		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";
+}
+
+
+function zeroCountNum(source:string):number{
+	var splitted = source.split(":")
+	var countNum = 0;
+	for(perItem in splitted){
+		if(perItem == "00"){
+			countNum += 1
+		}
+	}
+	return countNum
+}
+/**
+ * 自定义wifi变化广播监听器
+ */
+@Suppress("UNUSED_PARAMETER","DEPRECATION")
+class CustomBroadcastReceiver extends BroadcastReceiver {
+
+	mWifiManager: WifiManager|null = null;
+
+	constructor(wifiManager: WifiManager) {
+		super();
+		this.mWifiManager = wifiManager;
+	}
+
+	override onReceive(_context: Context, intent: Intent): void {
+
+
+		if (intent.action == WifiManager.WIFI_STATE_CHANGED_ACTION) {
+			let state =
+				intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_UNKNOWN)
+			if (state == WifiManager.WIFI_STATE_ENABLED) {
+				// 获取当前的connectInfo 并且进行数据封装
+				let uniWifiInfo = new UniWifiInfo(null)
+				//做一些异步操作
+				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)
+					let res = {
+						errMsg: 'onWifiConnected:ok',
+						errCode: 0,
+						wifi: uniWifiInfo
+					}
+					// wifi状态可用了，分发当前的链接状态给已注册的监听集合
+					for (let perCallback in Global.onWifiConnectCallbackList) {
+						perCallback(res);
+					}
+					// 封装仅SSID 数据对象
+					var connectedWithPartialInfo = {
+						SSID:uniWifiInfo.SSID
+					}
+					for (let perCallback in Global.onWifiConnectWithPartialInfoCallbackList) {
+						perCallback(connectedWithPartialInfo);
+					}
+
+				}, 100);
+			}
+
+		}
+
+
+		if (intent.action == WifiManager.SCAN_RESULTS_AVAILABLE_ACTION) {
+			// wifi 扫描结果回调
+			let results = this.mWifiManager!.scanResults;
+
+			if (results != null) {
+				Global.scanList = []
+				for (let scanResult in results) {
+					if (scanResult.SSID == null) {
+						continue;
+					}
+					Global.scanList.push(new UniWifiInfo(scanResult));
+				}
+
+				// 挨个通知，所有的监听器
+				for (let perCallback in Global.getWifiListCallbackList) {
+
+					const data = new JSONObject();
+					// let mainJsonStr = Gson().toJson(Global.scanList);
+					data["wifiList"] = Global.scanList
+					perCallback(data);
+				}
+
+			}
+
+		}
+	}
+
+}
+
+
+
+/************************* 下面是对外提供的函数 *************************/
+
+/**
+ * 开启wifi
+ */
+@Suppress("DEPRECATION")
+export function startWifi(option: WifiOption) {
+	
+	// 需要先开启wifi,才能使用后续的功能
+	let requestCode = 1001;
+	let permissionWifi = arrayOf("android.permission.ACCESS_FINE_LOCATION");
+	var result = {
+		errCode: 12001,
+		errMsg: "startWifi:premission loss",
+		errSubject:"uni-startWifi"
+	}
+	// 检查权限
+	if (ActivityCompat.checkSelfPermission(UTSAndroid.getUniActivity()!, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+
+		ActivityCompat.requestPermissions(UTSAndroid.getUniActivity()!, permissionWifi, requestCode)
+		// 尚不具备权限，返回错误
+		option.fail?.(result)
+		option.complete?.(result)
+
+		return;
+	}
+
+	// 具备了权限，继续前进
+	let wifiManager: WifiManager =
+		UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
+	// 用户没有开启wifi 总开关
+	if(!wifiManager.isWifiEnabled()){
+		// wifi 没开启
+		result.errCode = 12005;
+		result.errMsg = "wifi not turned on";
+		
+		option.fail?.(result);
+		option.complete?.(result);
+		return;
+	}
+	// 初始化wifi 状态广播监听，后续所有的api，均基于此
+	if (Global.mReceiver == null) {
+		Global.mReceiver = new CustomBroadcastReceiver(wifiManager)
+	}
+
+	let filter = new IntentFilter()
+	filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)
+	// @ts-ignore
+	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){
+			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列表
+ */
+@Suppress("DEPRECATION")
+export function getWifiList(option: WifiOption) {
+	
+	var result = {
+		errCode: 12000,
+		errMsg: "getWifiList:fail:not invoke startWifi",
+		errSubject:"uni-getWifiList"
+	}
+	
+	if (Global.mReceiver == null) {
+		// 还没调用startWifi 提示报错
+		option.fail?.(result)
+		option.complete?.(result)
+	
+		return
+	}
+	
+	let wifiManager: WifiManager =
+		UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
+	
+	wifiManager.startScan()
+
+	let ret = {
+		errCode: 0,
+		errMsg: "getWifiList:ok"
+	}
+	option.success?.(ret)
+	option.complete?.(ret)
+
+}
+
+
+
+/**
+ * wifi 链接成功的回调注册
+ */
+export function onWifiConnected(callback: UTSCallback) {
+	Global.onWifiConnectCallbackList.push(callback)
+}
+
+
+export function onWifiConnectedWithPartialInfo(callback: UTSCallback) {
+	Global.onWifiConnectWithPartialInfoCallbackList.push(callback)
+}
+
+
+/**
+ * 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) {
+	let callbackIndex = Global.onWifiConnectWithPartialInfoCallbackList.indexOf(callback)
+	if (callbackIndex > 0) {
+		Global.onWifiConnectWithPartialInfoCallbackList.splice(callbackIndex, 1);
+	}
+}
+
+/**
+ * 注册Wifi列表的监听事件
+ */
+export function onGetWifiList(callback: UTSCallback) {
+	Global.getWifiListCallbackList.push(callback)
+}
+/**
+ * 取消注册Wifi列表的监听事件
+ */
+export function offGetWifiList(callback: UTSCallback) {
+	let callbackIndex = Global.getWifiListCallbackList.indexOf(callback)
+	if (callbackIndex > 0) {
+		Global.getWifiListCallbackList.splice(callbackIndex, 1);
+	}
+}
+
+
+/**
+ * 链接指定wifi
+ */
+@Suppress("UNUSED_PARAMETER","DEPRECATION")
+export function connectWifi(option: WifiConnectOption) {
+	
+
+	var result = {
+		errCode: 12000,
+		errMsg: "connectWifi:fail:not invoke startWifi",
+		errSubject:"uni-connectWifi",
+	}
+	
+	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 
+	}
+	
+	// 执行后续的逻辑
+	let scanWifiInfo:UniWifiInfo|null = null
+	for (let scanResult in Global.scanList) {
+		
+		if (scanResult.SSID.equals(option.SSID)) {
+			scanWifiInfo = scanResult
+		}
+	}
+	
+	if(scanWifiInfo == null){
+		// 不在扫描列表中返回错误
+		option.fail?.(result)
+		option.complete?.(result)
+		return
+	}
+	
+	let wifiConfigration = wrapWifiConfiguration(scanWifiInfo.SSID,option.password,scanWifiInfo.securityType);
+	wifiConfigration.BSSID = scanWifiInfo.BSSID
+	let wifiManager: WifiManager =
+		UTSAndroid.getAppContext()!.getSystemService(Context.WIFI_SERVICE) as WifiManager
+	
+	// 如果已经存在了指定wifi 配置，移除之
+	let targetExistConfig:WifiConfiguration|null = null
+	let existingConfigs = wifiManager.getConfiguredNetworks();
+	for (let existingConfig in existingConfigs) {
+		if (existingConfig.SSID.equals("\"" + option.SSID + "\"")) {
+			targetExistConfig = existingConfig
+		}
+	}
+	// 如果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"
+			
+			option.fail?.(result)
+			option.complete?.(result)
+			
+			return
+		}
+		
+	}
+	
+	let currentConnect = wifiManager.getConnectionInfo()
+	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){
+			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){
+		
+			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){
+		// 出错了，返回错误
+		// 兜底的报错
+		result.errCode = 12010
+		result.errMsg = "connectWifi:fail:unknown error"
+		
+		option.fail?.(result)
+		option.complete?.(result)
+		return 
+	}
+	
+	wifiManager.saveConfiguration()
+	//scanWifiInfo 根据 partialInfo 填充给返回字段
+	if(option.partialInfo){
+		result['wifi'] = {
+			SSID:scanWifiInfo.SSID
+		}
+	}else{
+		result['wifi'] = 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,才能使用后续的功能
+	if (Global.mReceiver == null) {
+		var result = {
+			errNo: 12000,
+			errCode: 12000,
+			errMsg: "stopWifi:not init"
+		}
+		option.fail?.(result)
+		option.complete?.(result)
+
+		return
+	}
+	try{
+		UTSAndroid.getUniActivity()!.unregisterReceiver(Global.mReceiver)
+	}catch(e){
+		// 多次调用
+		//TODO handle the exception
+	}
+	
+	var result = {
+		errNo: 0,
+		errCode: 0,
+		errMsg: "stopWifi:ok"
+	}
+	option.success?.(result)
+	option.complete?.(result)
+
+}
+
+/**
+ * 获取当前连接中的wifi信息
+ */
+@Suppress("DEPRECATION")
+export function getConnectedWifi(option: GetConnectedWifiOptions) {
+
+	let wifiInfo = new UniWifiInfo(null)
+
+	var res = {
+		errCode: 12000,
+		errMsg: "getConnectedWifi:fail:not invoke startWifi",
+		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;
+	}
+
+	// TODO 应该try catch一下，把系统的错误码给返回来，然后和微信的错误码拉齐
+	// 需要先校验权限，没有位置权限无法获取wifi
+	const context = UTSAndroid.getAppContext();
+	if (context != null) {
+		const wm = context.getSystemService(
+			Context.WIFI_SERVICE
+		) as WifiManager;
+		// 测试android 12上可以使用
+		//@ts-ignore
+		const winfo = wm.getConnectionInfo();
+		
+		
+		console.log("option.partialInfo  === " + option.partialInfo);
+		wifiInfo.wrapConnectInfo(winfo);
+		// 判断一下是否wifi 关闭了
+		if(option.partialInfo!){
+			let ret = {
+				SSID : wifiInfo.SSID
+			}
+			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.errCode = 0
+		res.errMsg = "getConnectedWifi:ok"
+		
+		option.success?.(res)
+		option.complete?.(res)
+		return
+	}
+	option.fail?.(res)
+	option.complete?.(res)
+}
\ No newline at end of file

uni_modules/uni-wifi/utssdk/app-ios/Info.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>NSLocationWhenInUseUsageDescription</key>
+    <string>使用期间获取位置权限</string>
+  </dict>
+</plist>
\ No newline at end of file

uni_modules/uni-wifi/utssdk/app-ios/UTS.entitlements

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.developer.networking.wifi-info</key>
+	<true/>
+</dict>
+</plist>
\ No newline at end of file

uni_modules/uni-wifi/utssdk/app-ios/config.json

+{
+	"frameworks": [
+		"CoreLocation",
+		"SystemConfiguration"
+	],
+	"validArchitectures": [
+		"arm64", "armv7" ]
+}
\ No newline at end of file

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

+import { CLLocationManager, CLAuthorizationStatus, CLLocationManagerDelegate } from 'CoreLocation'
+import { CaptiveNetwork, kCNNetworkInfoKeySSID, kCNNetworkInfoKeyBSSID } from 'SystemConfiguration.CaptiveNetwork';
+import { NSArray, NSDictionary } from 'Foundation';
+import { CFString } from 'CoreFoundation';
+import { UIDevice } from 'UIKit';
+
+/**
+ * Wifi 函数通用入参封装
+ */
+type WifiOption = {
+	success?: (res: object) => void;
+	fail?: (res: object) => void;
+	complete?: (res: object) => void;
+};
+
+/**
+ * Wifi 链接参数封装 
+ */
+type WifiConnectOption = {
+	SSID: string;
+	BSSID: string;
+	password: string;
+	maunal: boolean;
+	partialInfo: boolean; //ios不生效
+	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 UniWifiInfo = {
+	SSID: string;
+	BSSID: string;
+	secure: boolean;
+	signalStrength: number;
+	frequency: number;
+}
+
+
+/* 
+ * 系统定位权限获取类
+ */
+class LocationPromiseService implements CLLocationManagerDelegate  {
+	static promiseCompletionHandler: ((res: boolean)=>void)[] = []
+	
+	manager?: CLLocationManager
+	
+	constructor(manager?: CLLocationManager) {
+		this.manager = manager
+	}
+	
+	initlizeManager(): boolean {
+		if (this.manager == null) {
+			this.manager = new CLLocationManager()
+			this.manager!.delegate = this
+		}
+		return true
+	}
+	
+	locationManager(manager: CLLocationManager, @argumentLabel("didChangeAuthorization") status: CLAuthorizationStatus) {
+		if (status == CLAuthorizationStatus.authorizedAlways || status == CLAuthorizationStatus.authorizedWhenInUse) {
+			LocationPromiseService.promiseCompletionHandler.forEach((handler): void => {
+				handler(true)
+			})
+		} else if (status == CLAuthorizationStatus.notDetermined) { 
+			manager.requestWhenInUseAuthorization()
+		} else if (status == CLAuthorizationStatus.denied) {
+			LocationPromiseService.promiseCompletionHandler.forEach((handler): void => {
+				handler(false)
+			})
+		}
+	}   
+	requestPromise(@escaping completion: (res: boolean)=>void) {
+		let status: CLAuthorizationStatus = CLLocationManager.authorizationStatus()
+		if (status == CLAuthorizationStatus.notDetermined) {
+			if (this.initlizeManager() == true) {
+				this.manager!.requestWhenInUseAuthorization()
+				LocationPromiseService.promiseCompletionHandler.push(completion)
+			}
+		} else if (status == CLAuthorizationStatus.authorizedAlways || status == CLAuthorizationStatus.authorizedWhenInUse) {
+			completion(true)
+		} else if (status == CLAuthorizationStatus.denied) {
+			if (CLLocationManager.locationServicesEnabled() == false && this.initlizeManager() == true) {
+				this.manager!.requestWhenInUseAuthorization()
+				LocationPromiseService.promiseCompletionHandler.push(completion)
+			}
+		} 
+	}
+}
+
+const locationPromiseService: LocationPromiseService = new LocationPromiseService(null)
+
+/* 
+ * 获取系统定位权限 
+ */
+function requestLocationPromise(@escaping completion: (res: boolean)=>void) {
+	locationPromiseService.requestPromise(completion)
+}
+
+/* 
+ * 获取当前连接的wifi信息（通过定位权限）
+ */
+function fetchConnectedWifiWithLocationPromise(option: GetConnectedWifiOptions) {
+	let arr = CNCopySupportedInterfaces()
+	let wifiInfo = new UniWifiInfo()
+	wifiInfo.BSSID = ""
+	wifiInfo.SSID = ""
+	wifiInfo.secure = false
+	wifiInfo.signalStrength = 0
+	wifiInfo.frequency = 0
+	
+	if (arr != null) {
+		let list = arr! as NSArray
+		let index = 0
+		while (index < list.count) { 
+			let item = list[index]
+			let interfaceName = item as string
+			let dic = CNCopyCurrentNetworkInfo(interfaceName as CFString)
+			if (dic != null) {
+				let dict = dic! as NSDictionary
+				let SSID = dict[kCNNetworkInfoKeySSID as string] 
+				let BSSID = dict[kCNNetworkInfoKeyBSSID as string]
+				
+				if (SSID != null && BSSID != null) {
+					let ssid = SSID! as string
+					let bssid = BSSID! as string
+					wifiInfo.SSID = ssid
+					wifiInfo.BSSID = bssid
+					wifiInfo.secure = false
+					wifiInfo.signalStrength = 0
+					wifiInfo.frequency = 0
+					break;
+				}
+			}
+			index++
+		}
+		
+		if (wifiInfo.BSSID.length > 0 && wifiInfo.SSID.length > 0) {
+			let res = {
+				errSubject: "uni-getConnectedWifi",
+				errCode: 0,
+				errMsg: "getConnectedWifi:ok",
+				wifi: wifiInfo,
+			}
+			option.success?.(res)
+			option.complete?.(res)
+		}else {
+			const res = { 
+				errSubject: "uni-getConnectedWifi", 
+				errCode: 12010, 
+				errMsg: "getConnectedWifi:system internal error"
+			}
+			option.fail?.(res)
+			option.complete?.(res)
+		}
+	}else {
+		const res = {
+			errSubject: "uni-getConnectedWifi", 
+			errCode: 12010, 
+			errMsg: "getConnectedWifi:system internal error"
+		}
+		option.fail?.(res)
+		option.complete?.(res)
+	}
+}
+
+
+
+/* 
+ * 保存全局数据信息
+ */
+class UniWiFiModuleGloabInfo {
+	static alreadyStartWifi: boolean
+}
+
+/* =================================== 对外暴露的接口 ==============================================*/
+
+
+
+/* 
+ * 初始化wifi模块 
+ */
+export function startWifi(option: WifiOption) {
+	UniWiFiModuleGloabInfo.alreadyStartWifi = true
+	let res = {
+		errSubject: "uni-startWifi",
+		errCode: 0, 
+		errMsg: "startWifi:ok"
+	}
+	option.success?.(res)
+	option.complete?.(res)
+}
+
+/* 
+ * 停止wifi模块 
+ */
+export function stopWifi(option: WifiOption) {
+	UniWiFiModuleGloabInfo.alreadyStartWifi = false
+	LocationPromiseService.promiseCompletionHandler = []	
+	let res = {
+		errSubject: "uni-stopWifi",
+		errCode: 0, 
+		errMsg: "stopWifi:ok"
+	}
+	option.success?.(res)
+	option.complete?.(res)
+}
+
+/* 
+ * 获取wifi列表, 在调用之前需要引导用户跳转到系统设置-WIFI设置页面，系统搜索周边wifi后app才能接收到回调
+ */
+export function getWifiList(option: WifiOption) {
+	let res = {
+		errSubject: "uni-getWifiList",
+		errCode: 12001, 
+		errMsg: "getWifiList:system not support"
+	}
+	option.fail?.(res)
+	option.complete?.(res)
+}
+
+/* 获取wifi列表的回调
+ * note: 请在getWifiList方法的回调里调用该方法
+ */
+export function onGetWifiList(callback: UTSCallback) {
+	
+}
+
+/* 
+ *	注销获取wifi列表的回调
+ */
+export function offGetWifiList(callback: UTSCallback) {
+
+}
+
+
+/* 
+ * 获取当前连接的wifi信息
+ */
+export function getConnectedWifi(option: GetConnectedWifiOptions) {
+	if (UniWiFiModuleGloabInfo.alreadyStartWifi == false) {
+		let res = {
+			errSubject: "uni-getConnectedWifi",
+			errCode: 12000, 
+			errMsg: "getConnectedWifi:not init",
+		}
+		option.fail?.(res)
+		option.complete?.(res)
+	} else{
+		if (UIDevice.current.systemVersion >= "13.0") {
+			requestLocationPromise((success) => {
+				if (success == true) {
+					fetchConnectedWifiWithLocationPromise(option)
+				}else {
+					let res = {
+						errSubject: "uni-getConnectedWifi",
+						errCode: 12007, 
+						errMsg: "getConnectedWifi:user denied",
+					}
+					option.fail?.(res)
+					option.complete?.(res)
+				}
+			})
+		} else{
+			fetchConnectedWifiWithLocationPromise(option)
+		}
+	}
+}
+
+/* 
+ * 连接wifi
+ */
+export function connectWifi(option: WifiConnectOption) {
+	let res = {
+		errSubject: "uni-connectWifi",
+		errCode: 12001, 
+		errMsg: "connectWifi:system not support"
+	}
+	option.fail?.(res)
+	option.complete?.(res)
+}
+
+
+/* 
+ * 连上wifi事件的监听函数
+ */
+export function onWifiConnected(callback: UTSCallback) {
+	
+}
+
+/* 
+ * 连上wifi事件的监听函数， wifiInfo仅包含ssid
+ */
+export function onWifiConnectedWithPartialInfo(callback: UTSCallback) {
+	
+}
+
+/* 
+ *	移除连接上wifi的事件的监听函数，不传此参数则移除所有监听函数。
+ */
+export function offWifiConnected(callback: UTSCallback | null) {
+
+}
+
+/* 
+ *	移除连接上wifi的事件的监听函数，不传此参数则移除所有监听函数。
+ */
+export function onOffWifiConnectedWithPartialInfo(callback: UTSCallback | null) {
+
+}
+
+/* 
+ * 设置 wifiList 中 AP 的相关信息。在 onGetWifiList 回调后调用，iOS特有接口。
+ */
+export function setWifiList(option: WifiOption) {
+	let res = {
+		errSubject: "uni-setWifiList",
+		errCode: 12001, 
+		errMsg: "setWifiList:system not support"
+	}
+	option.fail?.(res)
+	option.complete?.(res)
+}
\ No newline at end of file