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, 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)
			})
		}
	}   
	
	locationManagerDidChangeAuthorization(manager: CLLocationManager) {
		
	}
	
	locationManagerDidPauseLocationUpdates(manager: CLLocationManager) {
		
	}
	
	locationManagerDidResumeLocationUpdates(manager: CLLocationManager) {
		
	}
	
	locationManagerShouldDisplayHeadingCalibration(manager: CLLocationManager): boolean {
		return true
	}
	
	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()
	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 = {
				errCode: 0,
				errMsg: "getConnectedWifi:success",
				wifi: wifiInfo,
			}
			option.success?.(res)
			option.complete?.(res)
		}else {
			option.fail?.({errCode: 12000, errMsg: "current wifi is null"})
			option.complete?.({errCode: 12000, errMsg: "current wifi is null"})
		}
	}else {
		option.fail?.({errCode: 12000, errMsg: "current wifi is null"})
		option.complete?.({errCode: 12000, errMsg: "current wifi is null"})
	}
}



/* 
 * 保存全局数据信息
 */
class GloabInfo {
	static alreadyStartWifi: boolean
}

/* =================================== 对外暴露的接口 ==============================================*/



/* 
 * 初始化wifi模块 
 */
export function startWifi(option: WifiOption) {
	GloabInfo.alreadyStartWifi = true
	let res = {
		errCode: 0, 
		errMsg: "startWifi: ok"
	}
	option.success?.(res)
	option.complete?.(res)
}

/* 
 * 停止wifi模块 
 */
export function stopWifi() {
	GloabInfo.alreadyStartWifi = false
	LocationPromiseService.promiseCompletionHandler = []	
}

/* 
 * 获取wifi列表, 在调用之前需要引导用户跳转到系统设置-WIFI设置页面，系统搜索周边wifi后app才能接收到回调
 */
export function getWifiList(option: WifiOption) {
	let res = {
		errCode: 12001, 
		errMsg: "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) {
	let wifiInfo = new UniWifiInfo()
	wifiInfo.SSID = ""
	wifiInfo.BSSID = ""
	wifiInfo.secure = false
	wifiInfo.signalStrength = 0
	wifiInfo.frequency = 0
	
	if (GloabInfo.alreadyStartWifi == false) {
		let res = {
			errCode: 12000, 
			errMsg: "not invoke startWifi",
			wifi: wifiInfo
		}
		option.fail?.(res)
		option.complete?.(res)
	} else{
		if (UIDevice.current.systemVersion >= "13.0") {
			requestLocationPromise((success) => {
				if (success == true) {
					fetchConnectedWifiWithLocationPromise(option)
				}else {
					let res = {
						errCode: 12010, 
						errMsg: "have no location promise",
						wifi: wifiInfo
					}
					option.fail?.(res)
					option.complete?.(res)
				}
			})
		} else{
			fetchConnectedWifiWithLocationPromise(option)
		}
	}
}

/* 
 * 连接wifi
 */
export function connectWifi(option: WifiConnectOption) {
	let res = {
		errCode: 12001, 
		errMsg: "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 = {
		errCode: 12001, 
		errMsg: "system not support"
	}
	option.fail?.(res)
	option.complete?.(res)
}