nativescript-connectivity-manager-plugin
Version:
This plugin provides a connectivity manager of Android and iOS.
293 lines • 14.2 kB
JavaScript
import { Common } from "./connectivity-manager-impl.common";
import * as application from "@nativescript/core/application";
var Context = android.content.Context;
var WifiConfiguration = android.net.wifi.WifiConfiguration;
var ConnectivityManagerService = android.net.ConnectivityManager;
var WifiManagerService = android.net.wifi.WifiManager;
var LocationManagerService = android.location.LocationManager;
var NetworkRequest = android.net.NetworkRequest;
var NetworkCapabilities = android.net.NetworkCapabilities;
var WifiNetworkSpecifier = android.net.wifi.WifiNetworkSpecifier;
let IS_Q_VERSION = false;
try {
IS_Q_VERSION =
android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q;
}
catch (_a) {
IS_Q_VERSION = false;
}
export class ConnectivityManagerImpl extends Common {
constructor() {
super(...arguments);
this.WIFI_SSID_BLACKLIST = ["", " "];
this.wifiManager = application.android.context.getSystemService(Context.WIFI_SERVICE);
this.cellularManager = application.android.context.getSystemService(Context.TELEPHONY_SERVICE);
this.locationManager = application.android.context.getSystemService(Context.LOCATION_SERVICE);
this.connectivityManager = application.android.context.getSystemService(Context.CONNECTIVITY_SERVICE);
this.previousConnectionMetered = false;
this.previousConnectionWiFi = false;
this.previousSsid = undefined;
this.connectResolve = null;
this.disconnectResolve = null;
}
getSSID() {
return this.wifiManager.getConnectionInfo().getSSID();
}
getWifiNetworkId() {
return this.wifiManager.getConnectionInfo().getNetworkId();
}
isWifiEnabled() {
return this.wifiManager.isWifiEnabled();
}
isWifiConnected() {
if (!this.isWifiEnabled()) {
throw new Error("Wifi is not enabled.");
}
if (IS_Q_VERSION) {
return (this.connectivityManager.getNetworkCapabilities(this.connectivityManager.getActiveNetwork()) &&
this.connectivityManager
.getNetworkCapabilities(this.connectivityManager.getActiveNetwork())
.hasTransport(NetworkCapabilities.TRANSPORT_WIFI));
}
else {
return this.connectivityManager
.getNetworkInfo(ConnectivityManagerService.TYPE_WIFI)
.isConnected();
}
}
isCellularEnabled() {
return this.cellularManager.isDataEnabled();
}
isCellularConnected() {
if (!this.isCellularEnabled()) {
throw new Error("Cellular is not enabled.");
}
return this.connectivityManager
.getNetworkCapabilities(this.connectivityManager.getActiveNetwork())
.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR);
}
isGpsEnabled() {
return this.locationManager.isProviderEnabled(LocationManagerService.GPS_PROVIDER);
}
isGpsConnected() {
return this.locationManager.isProviderEnabled(LocationManagerService.NETWORK_PROVIDER);
}
async scanWifiNetworks() {
return new Promise((resolve) => {
application.android.registerBroadcastReceiver(WifiManagerService.SCAN_RESULTS_AVAILABLE_ACTION, () => {
application.android.unregisterBroadcastReceiver(WifiManagerService.SCAN_RESULTS_AVAILABLE_ACTION);
let wifiSsidList = [];
let wifiScanResult = this.wifiManager.getScanResults();
for (let i = 0; i < wifiScanResult.size(); i++) {
let wifi = wifiScanResult.get(i);
if (wifiSsidList.indexOf(wifi.SSID) == -1 &&
this.WIFI_SSID_BLACKLIST.indexOf(wifi.SSID) == -1) {
wifiSsidList.push(wifi.SSID);
}
}
resolve(wifiSsidList);
});
this.wifiManager.startScan();
});
}
async connectToWifiNetwork(ssid, password, milliseconds) {
return new Promise((resolve) => {
if (!this.isWifiEnabled()) {
throw new Error("Wi-Fi not enabled.");
}
try {
const that = this;
this.previousConnectionMetered = this.connectivityManager.isActiveNetworkMetered();
if (this.isWifiConnected()) {
this.previousConnectionWiFi = true;
this.previousSsid = this.getSSID();
}
else {
this.previousConnectionWiFi = false;
this.previousSsid = undefined;
}
this.connectResolve = resolve;
if (IS_Q_VERSION) {
let wifiNetworkSpecifier = new WifiNetworkSpecifier.Builder()
.setSsid(ssid)
.setWpa2Passphrase(password)
.build();
let networkRequest = new NetworkRequest.Builder()
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
.removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
.setNetworkSpecifier(wifiNetworkSpecifier)
.build();
this.forcedNetworkCallback = new (ConnectivityManagerService.NetworkCallback.extend({
onAvailable: function (network) {
console.log("Connected to the network");
that.connectivityManager.bindProcessToNetwork(network);
that.connectResolve(true);
},
onUnavailable: function () {
this.super.onUnavailable();
that.connectResolve(false);
},
}))();
console.log("Connecting to the network...");
this.connectivityManager.requestNetwork(networkRequest, this.forcedNetworkCallback, milliseconds);
}
else {
const ssidFormatted = `"${ssid}"`;
let conf = new WifiConfiguration();
conf.SSID = ssidFormatted;
if (password) {
conf.preSharedKey = '"' + password + '"';
conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
}
else {
conf.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
}
let timeoutInterval = setTimeout(() => {
resolve(false);
}, milliseconds);
let networkRequest = new NetworkRequest.Builder()
.addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
.build();
this.forcedNetworkCallback = new (ConnectivityManagerService.NetworkCallback.extend({
onAvailable: function (network) {
if (that.getSSID() == ssidFormatted) {
console.log("Connected to the network");
that.connectivityManager.bindProcessToNetwork(network);
that.connectivityManager.unregisterNetworkCallback(this);
that.connectResolve(true);
clearTimeout(timeoutInterval);
}
},
onUnavailable: function () {
this.super.onUnavailable();
},
}))();
this.connectivityManager.registerNetworkCallback(networkRequest, this.forcedNetworkCallback);
const list = this.wifiManager.getConfiguredNetworks();
let netId = -1;
for (let i = 0; i < list.size(); i++) {
const network = list.get(i);
if (network.SSID === ssidFormatted) {
netId = network.networkId;
break;
}
}
if (netId == -1) {
netId = this.wifiManager.addNetwork(conf);
}
this.wifiManager.enableNetwork(netId, true);
}
}
catch (error) {
throw new Error("Something went wrong wile connecting to the WiFi. + " + error);
}
});
}
hasInternet() {
return ConnectivityManagerImpl.hasInternet(this.connectivityManager, this.connectivityManager.getActiveNetwork());
}
static hasInternet(connectivityManager, network) {
return connectivityManager
.getNetworkCapabilities(network)
.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
}
async disconnectWifiNetwork(timeoutMs) {
return new Promise((resolve) => {
let that = this;
this.disconnectResolve = resolve;
let promiseTimeout = setTimeout(() => {
console.log("Ran into timeout when disconnecting and fetching new connection.");
resolve(false);
}, timeoutMs);
if (IS_Q_VERSION) {
let networkConnectivity = new (ConnectivityManagerService.NetworkCallback.extend({
onAvailable: function (network) {
ConnectivityManagerImpl.logConnectivityInfo(that.wifiManager, that.connectivityManager, network);
if (ConnectivityManagerImpl.isPreviousOrStableNetwork(that.wifiManager, that.connectivityManager, network, that.previousConnectionMetered, that.previousConnectionWiFi, that.previousSsid)) {
that.connectivityManager.bindProcessToNetwork(network);
that.disconnectResolve(true);
clearTimeout(promiseTimeout);
that.connectivityManager.unregisterNetworkCallback(this);
}
},
onLost: function (network) {
console.log("Disconnected.");
},
}))();
this.connectivityManager.registerNetworkCallback(new NetworkRequest.Builder().build(), networkConnectivity);
this.connectivityManager.unregisterNetworkCallback(this.forcedNetworkCallback);
}
else {
this.wifiManager.disableNetwork(this.wifiManager.getConnectionInfo().getNetworkId());
clearTimeout(promiseTimeout);
resolve(true);
}
});
}
static isPreviousOrStableNetwork(wifiManager, connectivityManager, network, previousNetworkMetered, previousNetworkWiFi, previousNetworkSsid) {
let isWifi = connectivityManager.getNetworkCapabilities(network)
? connectivityManager
.getNetworkCapabilities(network)
.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
: false;
if (previousNetworkWiFi && isWifi) {
let ssid = wifiManager.getConnectionInfo().getSSID();
return ssid == previousNetworkSsid;
}
else if (previousNetworkWiFi) {
return false;
}
let meteredNow = !connectivityManager
.getNetworkCapabilities(network)
.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
let hasInternet = ConnectivityManagerImpl.hasInternet(connectivityManager, network);
return meteredNow == previousNetworkMetered && hasInternet;
}
static logConnectivityInfo(wifiManager, connectivityManager, network) {
let activeNetwork = connectivityManager.getActiveNetwork();
let defaultActive = connectivityManager.isDefaultNetworkActive();
let boundNetwork = connectivityManager.getBoundNetworkForProcess();
let allNetworks = connectivityManager.getAllNetworks();
let ssid = wifiManager.getConnectionInfo().getSSID();
console.log("Connected via " +
ConnectivityManagerImpl.getInterfaceName(connectivityManager, network));
console.log("New network: " + network);
console.log("Active network: " + activeNetwork);
console.log("Active network adapter: " +
ConnectivityManagerImpl.getInterfaceName(connectivityManager, activeNetwork));
console.log("Default is active?: " + defaultActive);
console.log("Current bound network: " + boundNetwork);
console.log("Current bound network adapter: " +
ConnectivityManagerImpl.getInterfaceName(connectivityManager, boundNetwork));
console.log("All networks: " + allNetworks);
console.log("Current SSID:" + ssid);
}
static getInterfaceName(connectivityManager, activeNetwork) {
let linkProperties = connectivityManager.getLinkProperties(activeNetwork);
if (linkProperties == null) {
return "";
}
return linkProperties.getInterfaceName();
}
async waitUntilConnectedToWifi(milliseconds) {
return new Promise((resolve) => {
let intervalTimer = setInterval(() => {
if (this.isWifiConnected()) {
clearInterval(intervalTimer);
clearTimeout(timeout);
resolve(true);
}
}, 500);
let timeout = setTimeout(() => {
clearInterval(intervalTimer);
this.disconnectWifiAndRemoveNetwork();
throw new Error("Could not connect in the allowed time.");
}, milliseconds);
});
}
disconnectWifiAndRemoveNetwork() {
this.wifiManager.removeNetwork(this.getWifiNetworkId());
this.wifiManager.disconnect();
}
}
//# sourceMappingURL=connectivity-manager-impl.android.js.map