1

uni_modules/x-network-change/utssdk/app-android/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
+	package="io.dcloud.uni_modules.xNetworkChange">
+	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>
+

uni_modules/x-network-change/utssdk/app-android/config.json

@@ -0,0 +1,3 @@
+{
+  "minSdkVersion": "21"
+}

uni_modules/x-network-change/utssdk/app-android/index.uts

@@ -0,0 +1,133 @@
+import Build from 'android.os.Build';
+import Context from 'android.content.Context';
+import ConnectivityManager from 'android.net.ConnectivityManager';
+import NetworkCallback from 'android.net.ConnectivityManager.NetworkCallback';
+import Network from 'android.net.Network';
+import NetworkCapabilities from 'android.net.NetworkCapabilities';
+import NetworkRequest from 'android.net.NetworkRequest';
+import NetworkInfo from "android.net.NetworkInfo";
+import {xNetworkType} from "../interface"
+
+
+let netmarnger : ConnectivityManager | null = null;
+let networkCallback : ConnectivityManager.NetworkCallback | null = null;
+const context = UTSAndroid.getAppContext()!;
+
+//当前是否有网络。
+export function isNetworkAvailable() : Promise<boolean> {
+	let connectivityManager : ConnectivityManager | null = context!.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager | null;
+	if (connectivityManager == null) {
+		return Promise.resolve(false);
+	}
+
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+		// Android 6.0及以上版本
+		let network : Network | null = connectivityManager!.getActiveNetwork();
+		if (network == null) {
+			return Promise.resolve(false);
+		}
+
+		let capabilities : NetworkCapabilities | null = connectivityManager.getNetworkCapabilities(network!);
+		return Promise.resolve(capabilities != null &&
+			capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
+			capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED));
+	} else {
+		// Android 6.0以下版本
+		let networkInfo : NetworkInfo | null = connectivityManager.getActiveNetworkInfo();
+		return Promise.resolve(networkInfo != null && networkInfo.isConnected());
+	}
+}
+
+
+/**
+ * 获取网络类型
+ * @returns {Promise<xNetworkType|null>} "WiFi","Mobile","WiredNetwork",null网络
+ */
+export function getNetworkType() : Promise<xNetworkType | null> {
+	let connectivityManager : ConnectivityManager | null = context!.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager | null;
+	if (connectivityManager == null) {
+		return Promise.resolve(null);
+	}
+
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+		let network : Network | null = connectivityManager!.getActiveNetwork();
+		if (network == null) {
+			return Promise.resolve(null);
+		}
+
+		let capabilities : NetworkCapabilities | null = connectivityManager.getNetworkCapabilities(network!);
+		if (capabilities == null) {
+			return Promise.resolve(null);
+		}
+		if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+			return Promise.resolve("WiFi");
+		} else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+			return Promise.resolve("Mobile");
+		} else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
+			return Promise.resolve("WiredNetwork");
+		}
+	} else {
+		let networkInfo : NetworkInfo | null = connectivityManager.getActiveNetworkInfo();
+		if (networkInfo != null && networkInfo.isConnected()) {
+			let type = networkInfo.getType();
+			if (type == ConnectivityManager.TYPE_WIFI) {
+				return Promise.resolve("WiFi");
+			} else if (type == ConnectivityManager.TYPE_MOBILE) {
+				return Promise.resolve("Mobile");
+			} else {
+				return Promise.resolve("WiredNetwork");
+			}
+		}
+	}
+
+	return Promise.resolve(null);
+}
+
+@UTSJS.keepAlive
+function changeByBig(call : (conecting : boolean) => void) {
+	netmarnger = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+	class xnetworkCallback extends ConnectivityManager.NetworkCallback() {
+		override onAvailable(network : Network) {
+			super.onAvailable(network)
+			console.log("网络可用")
+			call(true)
+		}
+		override onLost(network : Network) {
+			super.onLost(network)
+			console.log("网络断开")
+			call(false)
+		}
+		override onCapabilitiesChanged(network : Network, networkCapabilities : NetworkCapabilities) {
+			super.onCapabilitiesChanged(network, networkCapabilities)
+		}
+	}
+	networkCallback = new xnetworkCallback() as NetworkCallback
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+		netmarnger!.registerDefaultNetworkCallback(networkCallback!)
+	} else {
+		//安卓5-8
+		let builder = NetworkRequest.Builder()
+		let networkRequest = builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build()
+		netmarnger!.registerNetworkCallback(networkRequest, networkCallback!)
+	}
+}
+//监听网络变化
+export function xNetChange(call : (conecting : boolean) => void) {
+	changeByBig(call);
+}
+//取消监听
+export function xUnNetChange() {
+	if (networkCallback != null && netmarnger != null) {
+		// @ts-ignore
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+			netmarnger!.unregisterNetworkCallback(networkCallback!)
+		} else {
+			// @ts-ignore
+			let builder = NetworkRequest.Builder()
+			let networkRequest = builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build()
+			// @ts-ignore
+			netmarnger!.unregisterNetworkCallback(networkCallback!)
+		}
+	}
+
+}

uni_modules/x-network-change/utssdk/app-harmony/index.uts

@@ -0,0 +1,272 @@
+import network, { NetworkResponse } from '@system.network';
+import { connection } from '@kit.NetworkKit';
+import { xNetworkType } from "../interface"
+import radio from '@ohos.telephony.radio'
+import { Emitter, onNativePageReady } from '@dcloudio/uni-runtime';
+import { BusinessError } from "@kit.BasicServicesKit";
+
+export type OnNetworkStatusChangeCallbackResult = {
+	/**
+	 * 当前是否有网络连接
+	 * @type boolean
+	 */
+	isConnected : boolean,
+	/**
+	 * 网络类型
+	 */
+	networkType : string
+};
+export type OnNetworkStatusChangeCallback = (result : OnNetworkStatusChangeCallbackResult) => void;
+export type OnNetworkStatusChange = (callback : OnNetworkStatusChangeCallback) => void;
+export type OffNetworkStatusChange = (callback : (result : any) => void) => void;
+
+
+interface IUniGetNetworkTypeEventEmitter {
+	on : (eventName : string, callback : Function) => void
+	once : (eventName : string, callback : Function) => void
+	off : (eventName : string, callback ?: Function) => void
+	emit : (eventName : string, ...args : (Object | undefined | null)[]) => void
+}
+const UniGetNetworkTypeEventEmitter = new Emitter() as IUniGetNetworkTypeEventEmitter
+function networkGetType() {
+	return new Promise<number>((resolve, reject) => {
+		try {
+			radio.getPrimarySlotId()
+				.then((slotId : number) => radio.getSignalInformationSync(slotId))
+				.then((signalInformation : Array<radio.SignalInformation>) => {
+					const data = signalInformation[0]
+					if (data && data.signalType) {
+						resolve(signalType(data.signalType))
+					} else {
+						resolve(NetworkinfoType.NONE)
+					}
+				})
+		} catch (error) {
+			reject(error as BusinessError)
+		}
+	})
+}
+
+enum NetworkinfoType {
+	// 网络连接状态未知
+	UNKNOW = 0,
+	// 未连接网络
+	NONE = 1,
+	// 有线网络
+	ETHERNET = 2,
+	// 无线WIFI网络
+	WIFI = 3,
+
+	"2G" = 4,
+	"3G" = 5,
+	"4G" = 6,
+	"5G" = 7,
+}
+
+
+function signalType(resultObj : radio.NetworkType) : number {
+	switch (resultObj) {
+		case radio.NetworkType.NETWORK_TYPE_GSM:
+		case radio.NetworkType.NETWORK_TYPE_CDMA:
+			return NetworkinfoType['2G']
+		case radio.NetworkType.NETWORK_TYPE_WCDMA:
+		case radio.NetworkType.NETWORK_TYPE_TDSCDMA:
+			return NetworkinfoType['3G']
+		case radio.NetworkType.NETWORK_TYPE_LTE:
+			return NetworkinfoType['4G']
+		case radio.NetworkType.NETWORK_TYPE_NR:
+			return NetworkinfoType['5G']
+		case radio.NetworkType.NETWORK_TYPE_UNKNOWN:
+			return NetworkinfoType.UNKNOW
+		default:
+			return NetworkinfoType.NONE
+	}
+}
+
+// 构造单例对象
+class GlobalContext {
+	public netList : connection.NetHandle[] = [];
+	public netHandle : connection.NetHandle | null = null;
+	private constructor() { }
+	private static instance : GlobalContext;
+
+	public static getContext() : GlobalContext {
+		if (!GlobalContext.instance) {
+			GlobalContext.instance = new GlobalContext();
+		}
+		return GlobalContext.instance;
+	}
+}
+
+
+//当前是否有网络。
+export function isNetworkAvailable() : Promise<boolean> {
+	return new Promise((resolve) => {
+		try {
+			radio.getPrimarySlotId()
+				.then((slotId : number) => radio.getSignalInformationSync(slotId))
+				.then((signalInformation : Array<radio.SignalInformation>) => {
+					const data = signalInformation[0]
+					if (data && data.signalType) {
+						resolve(signalType(data.signalType) != NetworkinfoType.NONE)
+					} else {
+						resolve(false)
+					}
+				})
+		} catch (error) {
+			resolve(false)
+		}
+	})
+}
+
+export function getNetworkType() : Promise<xNetworkType | null> {
+	return new Promise((resolve, reject) => {
+		try {
+			// 调用getDefaultNet方法，获取默认的数据网络(NetHandle)
+			connection.getDefaultNet().then((data : connection.NetHandle) => {
+				if (data) {
+					GlobalContext.getContext().netHandle = data;
+					// 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息
+					connection.getNetCapabilities(GlobalContext.getContext().netHandle!).then((data : connection.NetCapabilities) => {
+						// 获取网络类型(bearerTypes)
+						const bearerTypes : Set<number> = new Set(data.bearerTypes);
+						const bearerTypesNum = Array.from(bearerTypes.values());
+						for (const item of bearerTypesNum) {
+							if (item == connection.NetBearType.BEARER_CELLULAR) {
+								// 蜂窝网
+								networkGetType().then(() => {
+									resolve('Mobile')
+								}).catch(reject)
+							} else if (item == connection.NetBearType.BEARER_WIFI) {
+								// Wi-Fi网络
+								resolve('WiFi')
+							} else if (item == connection.NetBearType.BEARER_ETHERNET) {
+								// 以太网网络
+								resolve('WiredNetwork')
+							} else {
+								resolve('Other')
+							}
+						}
+					}).catch((err : BusinessError) => {
+						reject(err)
+					})
+				}
+			})
+		} catch (error) {
+			reject(null)
+		}
+
+	})
+}
+
+function invokeOnNetworkStatusChange(networkType : string) {
+	// UniGetNetworkTypeEventEmitter.emit(
+	// 	'networkStatusChange',
+	// 	{
+	// 		isConnected: networkType !== NetworkinfoType[1],
+	// 		networkType: networkType.toLocaleLowerCase(),
+	// 	} as OnNetworkStatusChangeCallbackResult
+	// )
+	
+	UniGetNetworkTypeEventEmitter.emit('networkStatusChange',networkType !== NetworkinfoType[1])
+}
+
+function getCurrentType() {
+	return new Promise<number>((resolve, reject) => {
+		// 调用getDefaultNet方法，获取默认的数据网络(NetHandle)
+		connection.getDefaultNet().then((data : connection.NetHandle) => {
+			if (data) {
+				GlobalContext.getContext().netHandle = data;
+				// 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息
+				connection.getNetCapabilities(GlobalContext.getContext().netHandle!).then((data : connection.NetCapabilities) => {
+					// 获取网络类型(bearerTypes)
+					const bearerTypes : Set<number> = new Set(data.bearerTypes);
+					const bearerTypesNum = Array.from(bearerTypes.values());
+					for (const item of bearerTypesNum) {
+						if (item == connection.NetBearType.BEARER_CELLULAR) {
+							// 蜂窝网
+							networkGetType().then(resolve).catch(reject)
+						} else if (item == connection.NetBearType.BEARER_WIFI) {
+							// Wi-Fi网络
+							resolve(NetworkinfoType.WIFI)
+						} else if (item == connection.NetBearType.BEARER_ETHERNET) {
+							// 以太网网络
+							resolve(NetworkinfoType.ETHERNET)
+						} else {
+							resolve(NetworkinfoType.UNKNOW)
+						}
+					}
+				}).catch((err : BusinessError) => {
+					reject(err)
+				})
+			}
+		})
+	})
+}
+
+
+
+class Network {
+	static netConnection : connection.NetConnection | null = null
+
+	constructor() {
+		Network.netConnection = connection.createNetConnection()
+	}
+
+	static ohoSubscribe() {
+		if (!Network.netConnection) {
+			Network.netConnection = connection.createNetConnection()
+		}
+
+		if (Network.netConnection) {
+
+			Network.netConnection.register((err : BusinessError) => { })
+			Network.netConnection.on('netCapabilitiesChange', (capability : connection.NetCapabilityInfo) => {
+				const NetBearType = capability?.netCap?.bearerTypes[0]
+				let networkType = ''
+				switch (NetBearType) {
+					case connection.NetBearType.BEARER_CELLULAR:
+						getCurrentType().then((type : number) => {
+							invokeOnNetworkStatusChange(NetworkinfoType[type])
+						}).catch(() => {
+							invokeOnNetworkStatusChange(NetworkinfoType[1])
+						})
+						return
+					case connection.NetBearType.BEARER_WIFI:
+						networkType = NetworkinfoType[3]
+						break
+					case connection.NetBearType.BEARER_ETHERNET:
+						networkType = NetworkinfoType[2]
+						break
+					/* case connection.NetBearType.BEARER_VPN:
+					  networkType = 'vpn'
+					  break */
+					default:
+						networkType = NetworkinfoType[1]
+				}
+				invokeOnNetworkStatusChange(networkType)
+				
+			})
+			Network.netConnection.on('netLost', (netLost : connection.NetHandle) => {
+				invokeOnNetworkStatusChange(NetworkinfoType[1])
+			})
+		}
+	}
+}
+
+new Network()
+
+type CallType = (conecting : boolean) => void;
+let call : CallType = (conecting : boolean) => { }
+export const xNetChange = (callback : CallType) => {
+	call = callback;
+	UniGetNetworkTypeEventEmitter.on('networkStatusChange', call)
+}
+//取消监听
+export function xUnNetChange() {
+	UniGetNetworkTypeEventEmitter.off('networkStatusChange', call)
+}
+
+onNativePageReady().then(() => {
+	Network.ohoSubscribe()
+})

uni_modules/x-network-change/utssdk/app-harmony/module.json5

@@ -0,0 +1,20 @@
+{
+  "module": {
+    "name": "uni_modules__x_network_change",
+    "type": "har",
+    "deviceTypes": [
+      "default",
+      "tablet",
+      "2in1"
+    ],
+    "requestPermissions": [
+      {
+        "name": "ohos.permission.INTERNET",
+        "usedScene": {
+          "when": "inuse"
+        }
+      },
+      {"name": "ohos.permission.GET_NETWORK_INFO"}
+    ]
+  }
+}

uni_modules/x-network-change/utssdk/app-ios/PrivacyInfo.xcprivacy

@@ -0,0 +1,14 @@
+<?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>NSPrivacyAccessedAPITypes</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyTracking</key>
+	<false/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+</dict>
+</plist>

uni_modules/x-network-change/utssdk/app-ios/config.json

@@ -0,0 +1,3 @@
+{
+  "deploymentTarget": "12"
+}

uni_modules/x-network-change/utssdk/app-ios/index.uts

@@ -0,0 +1,72 @@
+import { NWPathMonitor, NWPath, NWInterface } from 'Network';
+import { DispatchQueue } from "Dispatch"
+import { xNetworkType } from "../interface"
+let network = new NWPathMonitor()
+
+@UTSJS.keepAlive
+export function xNetChange(call : (conecting : boolean) => void) {
+	network.pathUpdateHandler = (nwpath : NWPath) => {
+		if (nwpath.status == NWPath.Status.satisfied) {
+			DispatchQueue.main.async(execute = () : void => {
+				call(true)
+			})
+		} else {
+			DispatchQueue.main.async(execute = () : void => {
+				call(false)
+			})
+		}
+	}
+	network.start(queue = DispatchQueue.global())
+}
+export function xUnNetChange() {
+	let network = new NWPathMonitor()
+	network.cancel()
+}
+
+//当前是否有网络。
+export function isNetworkAvailable() : Promise<boolean> {
+	return new Promise((res) => {
+		let network2 = new NWPathMonitor()
+		network2.pathUpdateHandler = (nwpath : NWPath) => {
+			if (nwpath.status == NWPath.Status.satisfied) {
+				DispatchQueue.main.async(execute = () : void => {
+					res(true)
+				})
+			} else {
+				DispatchQueue.main.async(execute = () : void => {
+					res(false)
+				})
+			}
+			network2.cancel()
+		}
+		network2.start(queue = DispatchQueue.global())
+	})
+}
+
+export function getNetworkType() : Promise<xNetworkType | null> {
+	return new Promise((res) => {
+		let network2 = new NWPathMonitor()
+		network2.pathUpdateHandler = (nwpath : NWPath) => {
+			if (nwpath.status == NWPath.Status.satisfied) {
+				DispatchQueue.main.async(execute = () : void => {
+					if (nwpath.usesInterfaceType(NWInterface.InterfaceType.wifi)) {
+						res('WiFi')
+					} else if (nwpath.usesInterfaceType(NWInterface.InterfaceType.cellular)) {
+						res('Mobile')
+					} else if (nwpath.usesInterfaceType(NWInterface.InterfaceType.wiredEthernet)) {
+						res('WiredNetwork')
+					} else {
+						res('Other')
+					}
+
+				})
+			} else {
+				DispatchQueue.main.async(execute = () : void => {
+					res(null)
+				})
+			}
+			network2.cancel()
+		}
+		network2.start(queue = DispatchQueue.global())
+	})
+}

uni_modules/x-network-change/utssdk/interface.uts

@@ -0,0 +1 @@
+export type xNetworkType = "WiFi"|"Mobile"|"WiredNetwork"|"Other"|null

uni_modules/x-network-change/utssdk/mp-weixin/index.uts

@@ -0,0 +1,55 @@
+import { xNetworkType } from "../interface"
+let netSuccess : any | null = null;
+let netFail : any | null = null;
+let callfun = (conecting : boolean) => { }
+const statChangeCall = (res : any) => {
+	console.log(res)
+	callfun(res?.isConnected ?? false)
+}
+export function xNetChange(call : (conecting : boolean) => void) {
+	callfun = call
+	wx.onNetworkStatusChange(statChangeCall)
+}
+export function xUnNetChange() {
+	wx.offNetworkStatusChange(statChangeCall)
+}
+//当前是否有网络。
+export function isNetworkAvailable() : Promise<boolean> {
+	return new Promise((res) => {
+		wx.getNetworkType({
+			success(res) {
+				const networkType = res.networkType
+				if (networkType === 'none') {
+					res(false)
+				} else {
+					res(true)
+				}
+			},
+			fail(err) {
+				res(false)
+			}
+		})
+	})
+}
+//获取当前网络状态。
+export function getNetworkType() : Promise<xNetworkType | null> {
+	return new Promise((res) => {
+		wx.getNetworkType({
+			success(res) {
+				const networkType = res.networkType
+				if (networkType === 'none') {
+					res(null)
+				} else if (networkType == 'wifi') {
+					res('WiFi')
+				} else if (['2g', '3g', '4g', '5g'].includes(networkType){
+					res('Mobile')
+				} else {
+					res('Other')
+				}
+			},
+			fail(err) {
+				res(null)
+			}
+		})
+	})
+}

uni_modules/x-network-change/utssdk/web/index.uts

@@ -0,0 +1,50 @@
+import { xNetworkType } from "../interface"
+let netSuccess : any = null;
+let netFail : any = null;
+export function xNetChange(call : (conecting : boolean) => void) {
+	netSuccess = () => {
+		call(true)
+	}
+	netFail = () => {
+		call(false)
+	}
+	window.addEventListener('online', netSuccess)
+	window.addEventListener('offline', netFail)
+}
+export function xUnNetChange() {
+	if (netSuccess) {
+		window.removeEventListener('online', netSuccess!)
+	}
+	if (netFail) {
+		window.removeEventListener('offline', netFail!)
+	}
+}
+
+//当前是否有网络。
+export function isNetworkAvailable() : Promise<boolean> {
+	return Promise.resolve(window.navigator.onLine);
+}
+
+export function getNetworkType() : Promise<xNetworkType | null> {
+	if ('connection' in navigator) {
+		const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+		if (!window.navigator.onLine) {
+			return Promise.resolve(null);
+		}
+		if (connection?.type != undefined) {
+			if (connection.type == 'cellular') {
+				return Promise.resolve("Mobile");
+			} else if (['wifi', 'wimax', 'ethernet'].includes(connection.type)) {
+				return Promise.resolve("Wifi");
+			} else {
+				return Promise.resolve("Other");
+			}
+		} else {
+			return Promise.resolve("Mobile");
+		}
+
+	} else {
+		console.log('浏览器不支持Network Information API');
+		return Promise.resolve(null);
+	}
+}