272 lines
8.1 KiB
Plaintext
272 lines
8.1 KiB
Plaintext
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()
|
|
}) |