NativeScript/packages/core/connectivity/index.android.ts

import { android as androidApp, getNativeApplication } from '../application';
export enum connectionType {
	none = 0,
	wifi = 1,
	mobile = 2,
	ethernet = 3,
	bluetooth = 4,
	vpn = 5,
}

const wifi = 'wifi';
const mobile = 'mobile';
const ethernet = 'ethernet';
const bluetooth = 'bluetooth';
const vpn = 'vpn';

// Get Connection Type
function getConnectivityManager(): android.net.ConnectivityManager {
	return getNativeApplication().getApplicationContext().getSystemService(android.content.Context.CONNECTIVITY_SERVICE);
}

function getActiveNetworkInfo(): android.net.NetworkInfo {
	let connectivityManager = getConnectivityManager();
	if (!connectivityManager) {
		return null;
	}

	return connectivityManager.getActiveNetworkInfo();
}

function getNetworkCapabilities() {
	const connectivityManager = getConnectivityManager() as any;
	const network = connectivityManager.getActiveNetwork();
	const capabilities = connectivityManager.getNetworkCapabilities(network);
	if (capabilities == null) {
		return connectionType.none;
	}

	const NetworkCapabilities = (android as any).net.NetworkCapabilities;

	if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
		return connectionType.wifi;
	}

	if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
		return connectionType.mobile;
	}

	if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
		return connectionType.ethernet;
	}

	if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH)) {
		return connectionType.bluetooth;
	}

	if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
		return connectionType.vpn;
	}

	return connectionType.none;
}

export function getConnectionType(): number {
	if (android.os.Build.VERSION.SDK_INT >= 28) {
		return getNetworkCapabilities();
	} else {
		let activeNetworkInfo = getActiveNetworkInfo();
		if (!activeNetworkInfo || !activeNetworkInfo.isConnected()) {
			return connectionType.none;
		}

		let type = activeNetworkInfo.getTypeName().toLowerCase();
		if (type.indexOf(wifi) !== -1) {
			return connectionType.wifi;
		}

		if (type.indexOf(mobile) !== -1) {
			return connectionType.mobile;
		}

		if (type.indexOf(ethernet) !== -1) {
			return connectionType.ethernet;
		}

		if (type.indexOf(bluetooth) !== -1) {
			return connectionType.bluetooth;
		}

		if (type.indexOf(vpn) !== -1) {
			return connectionType.vpn;
		}
	}

	return connectionType.none;
}

function startMonitoringLegacy(connectionTypeChangedCallback) {
	let onReceiveCallback = function onReceiveCallback(context: android.content.Context, intent: android.content.Intent) {
		let newConnectionType = getConnectionType();
		connectionTypeChangedCallback(newConnectionType);
	};
	let zoneCallback = <any>zonedCallback(onReceiveCallback);
	androidApp.registerBroadcastReceiver(android.net.ConnectivityManager.CONNECTIVITY_ACTION, zoneCallback);
}

let callback;
let networkCallback;
let notifyCallback;
export function startMonitoring(connectionTypeChangedCallback: (newConnectionType: number) => void): void {
	if (android.os.Build.VERSION.SDK_INT >= 28) {
		const manager = getConnectivityManager();
		if (manager) {
			notifyCallback = () => {
				let newConnectionType = getConnectionType();
				let zoneCallback = <any>zonedCallback(connectionTypeChangedCallback);
				zoneCallback(newConnectionType);
			};
			const ConnectivityManager = android.net.ConnectivityManager;
			if (!networkCallback) {
				@NativeClass
				class NetworkCallbackImpl extends ConnectivityManager.NetworkCallback {
					onAvailable(network: android.net.Network) {
						notifyCallback();
					}
					onCapabilitiesChanged(network: android.net.Network, networkCapabilities: android.net.NetworkCapabilities) {
						notifyCallback();
					}
					onLost(network) {
						notifyCallback();
					}
					onUnavailable() {
						notifyCallback();
					}
				}
				networkCallback = NetworkCallbackImpl;
			}
			callback = new networkCallback();
			manager.registerDefaultNetworkCallback(callback);
		}
	} else {
		startMonitoringLegacy(connectionTypeChangedCallback);
	}
}

export function stopMonitoring(): void {
	if (android.os.Build.VERSION.SDK_INT >= 28) {
		const manager = getConnectivityManager() as any;
		if (manager && callback) {
			manager.unregisterNetworkCallback(callback);
			notifyCallback = null;
			callback = null;
		}
	} else {
		androidApp.unregisterBroadcastReceiver(android.net.ConnectivityManager.CONNECTIVITY_ACTION);
	}
}